MacWorld 1997 September/Macworld (1997-09).dmg/Serious Software/Cherwell Scientific Demos/pro Fit/pro Fit 5.0 demo (fpu).sea/pro Fit 5.0 demo (fpu)/External Modules/External modules sources/Pascal/proFit_interface.p

Text File | 1996-05-19 | 127KB | 4,158 lines

{****************************************************************************** }
{  proFit_interface.p                                                   }
{*******************************************************************************}
{ History:                                                                    }
{  24.03.96:    added SetTextFileFormat, changed SaveDataAsText }
{  17.03.96:    added GetAndSetStatus }
{  15.03.96:    added NumberToStr255, Str255ToNumber }
{  10.03.96:    added GetFunctionParamName, CancelEvent }
{  06.03.96:    fixed a bug where the wrong selector for StopExecution was used }
{  29.02.95:    added WriteText, B5 and later                                  }
{  21.02.95:    added SetWindowInfo, SetBoxTitle and InputBox for strings, B5 and later}
{  30.12.95:    compatibility with MWerks 7 (68k+PPC) and ThinkPascal }
{  15.12.95:    5.0 release                                            }
{  27.01.95:    added conditionals for compatibility with                     }
{            Metrowerks Pascal 68k/PPC and universal headers 2.0a3            }
{  26.09.94:    4.2.0 release                                                                                                   }
{*******************************************************************************}




{ Welcome to the pro Fit external modules!                                                                        }
{ ---------------------------------------                                                                    }

{ External modules are pieces of code that you produce with your favorite compiler and that                }
{ you can build into pro Fit as functions or "user" programs.                                                    }

{ If it is the first time you do something with external modules and you want to see what is                }
{ needed to implement them, just take a look at the example files.                                            }

{ For example you might want to study the file ErrorFunc.p and look at the functions that are            }
{ defined there.                                                                                                    }

{ Most function names are the same ones used for defining functions and programs                        }
{ within pro Fit.                                                                                                    }
{ To define your own external module, simply fill in these functions with your code.                        }

{ Have a look at the pro Fit user manual for details on the parameter lists of these                        }
{ functions.                                                                                                        }

{ In order to build an external function or program, you must compile and link the                            }
{ following files:                                                                                                    }

{      proFit_interface.p            ("glue" code standing between pro Fit and your procedures)                }
{      XXXXXX.p                        (your procedures, where XXXXXX is a name you define)                    }

{ Of course you can add other files if you need them (such as the SANE library and interface).            }
{ Also, depending on the compiler you use, you may have to add additional                                    }
{ modules containing call glues for system traps (for example, in Think Pascal you must add             }
{ Interface.lib and DRVRRuntime.lib to your project).                                                            }

{ When compiling this file under Metrowerks Pascal, you need CodeWarrior 5 or later                    }
{ with the universal interfaces version 2.0                                                                    }

{ Compiling instructions for Power Macintosh (PowerPC):                                            }
{ -----------------------------------------------------                                        }

{ Compile your files as a "shared libary" or, more accurately, as an "application                        }
{ extension". The code should reside in the data fork (not a resource) and it should                        }
{ export the function main() as it is defined in the template files provided.                            }
{ The type of the file you create must be 'ftCD', its creator must be 'NLft'.                        }


{ Compiling instructions for 68XXX:                                                            }
{ ---------------------------------                                                            }

{ Compile your files and link them in a single resource of type 'NLft' (the ID number                        }
{ can be any number >128 you like). Make sure that your code consists of a single segment.                        }
{ Refer to your compiler's manual if you don't know how to compile code for a resource.                        }
{ Put your resource into a file having the type 'ftCD' and the creator 'NLft'.                        }

{ Before compiling, make sure that you choose the compiler options that are compatible                        }
{ with the version of pro Fit you use:                        }

{ If you use the FPU version of pro Fit, make sure that your extended variables are 12                        }
{ bytes longint. In Think Pascal, check "68020/68030" and "68881/68882"                                 }
{ under Compile Options.                                                                    }

{ If you use the non-FPU version of pro Fit, make sure that your extended variables are                        }
{ 10 bytes longint. In Think Pascal, uncheck  "68020/68030" and "68881/68882"                        }
{ under Compile Options.                                                                        }

{ The external module is a compiled code resource that provides a procedure called 'main'.                        }
{ You must make sure that main is at the beginning of your code. Under Symantec's                        }
{ compilers, this is done automatically. Under MPW, you must make sure that main()                        }
{ is the first routine that is compiled and linked.                                            }

{ ***************************************************************************************            }


unit proFit_interface;

interface


{     ****************************************************************************************                        }

{     The following are the type definitions that serve as an interface between the                        }
{     external module and pro Fit. These declarations describe exactly how pro Fit                        }
{     expects the external module to arrange the information it provides, and how the                        }
{     information provided by pro Fit is arranged.                                                    }
{     Don't even think of changing something in this file. The informations it contains                        }
{     are vital to the external module in their present, original form. They are deadly if                        }
{     you modify them.                        }
{     ANY change in a type definition (e.g. changing the ranges of an array or the                            }
{     order of the fields in a record) is guaranteed to cause very ugly consequences.                        }
{                                                                                     }
{     For a detailed description of these declarations and their use, see the                        }
{     pro Fit user manual.                                                                }
{                                                                                     }


{$IFC UNDEFINED POWERPC}
    { if this is not defined, we assume that this is a 68k compiler             }
    {$SETC POWERPC := false            }
{$ENDC}

{$IFC UNDEFINED THINK_PASCAL }
    { if this is the think pascal compiler}
    { then we don't need any "uses" at all}
    {$IFC UNDEFINED UsingIncludes}
        {$SETC UsingIncludes := 0}
    {$ENDC}

        {$IFC NOT POWERPC}
    uses
        Types, TextUtils, Files, Files,QuickDraw, Events;
        {$ELSEC}
    uses
        Types, TextUtils, MixedMode, Files, Quickdraw, Events;
        {$ENDC}

{$ENDC}

{$IFC UNDEFINED __CONDITIONALMACROS__}
    { __CONDITIONALMACROS__ would be defined in ConditionalMacros.p of the universal headers version 2 or later. }
    { if it is not defined, we assume that this is a 68k compiler: }
    {$SETC GENERATINGPOWERPC := false}
    {$SETC GENERATING68K := true}
{$ENDC}

{$IFC NOT UNDEFINED MWERKS AND GENERATING68K}
    function SetCurrentA4: longint;
        C;
    external;
    function SetA4 (newA4: longint): longint;
    external;
    {$SETC SET_A4 := true}
{$ENDC}



    const
        versionNumber = 1;            { the version number of this implementation             }


        isFunction = 1;                { constants used in the procedure Setup to set the parameter moduleKind            }
        isProgram = 2;
        isMacro = 3;

        drawingType = 'ftGF';            { window types, used by DoNewWindow, etc. }
        dataType = 'ftLS';
        textType = 'ftFC';
        defaultType = '****';

        gaussDistr = 1;                { error distributions, used for setting the parameters of the SetFitDefaults routine  }
        doubleExpDistr = 2;
        lorentzDistr = 3;
        andrewDistr = 4;
        tukeyDistr = 5;

        defaultFormat = 0;            { Drawing window file formats }
        pictFormat = 1;
        epsFormat = 2;

        floatColumn = 0;            { data column types         }
        doubleColumn = 1;
        textColumn = 128;

        noErrors = 0;    {error bar types, used for setting the "errors" parameter in the OpenDataSet routine}
        eBarY = 1;
        eBarX = 2;
        asymmEBarY = 4;
        asymmEBarX = 8;

        xAxis = 0;    { constants used for the routines accessing the current x or y axis, such as "SetRange"}
        yAxis = 1; { used to distinguish between Y and X axes.                }

        equalToMain = 1;    { constants used for setting the "flags" field of the SetAxisAttributes routine        }
        drawAxisLine = 2;
        drawTicks = 4;
        drawMajorTickLabels = 8;
        drawMinorTickLabels = $00000010;
        plusSideTicks = $00000020;
        minusSideTicks = $00000040;
        plusSideLabels = $00000080;
        labelsOutsideFrame = $00000100;

        drawFrame = 2;    { constants used for setting the "flags" field in calls to the SetGraphAttributes routine             }
        drawMajorGridX = 4;
        drawMinorGridX = 8;
        drawMajorGridY = $00000010;
        drawMinorGridY = $00000020;
        plotBehindAxes = $00000040;
        gridInFront = $00000080;
        gridInMiddle = $00000100;

        maxNrParams = 64;            { the maximum number of parameters used by a function }
        maxParamNameLength = 31;        { the maximum length of a parameter name }

        maxNrInputValues = 6;        { the maxiumum number of input values in the input dialog box             }

    type

{$ALIGN MAC68K}
{ ************Type definition for the "InputBox" ************ }
        ExtendedPtr = ^extended;
        inputRec = packed array[1..maxNrInputValues] of record    { information type for the input dialog box             }
                x: ExtendedPtr;
                s: ^str255;
            end;


{ ************ type definitions for "GetDefaultData" ************** }

        DataInfo = record          { this data structure can be used when calling GetDefaultData.                }

                xMin, xMax, xPosMin, xNegMax: extended;    { set if the "x" array was calculated                    }
                yMin, yMax, yPosMin, yNegMax: extended;    { set if the "y" array was calculated                    }

                ordered,                { true if the x-array is ordered such that x[i+1]>=x[i], for all i.                    }

                zeroYErrors,            { true if at least one y-error is 0                    }
                invalidYErrors,            { true if at least one y-error is invalid or 0                    }
                zeroXErrors,            { true if at least one x-error is 0                    }
                invalidXErrors: boolean;    { true if at least one x-error is invalid or 0                    }
            end;
        DataInfoPtr = ^DataInfo;

        ExtendedArray = array[0..0] of extended; { Variable size array of native double numbers. }
        ExtendedArrayPtr = ^ExtendedArray;         { GetDefaultData: Index [0] is reserved. First valid index is [1].}
        ExtendedArrayHandle = ^ExtendedArrayPtr;  { Handle to an array of native extended numbers }
        ExtendedArrayHandlePtr = ^ExtendedArrayHandle;

        LongArray = array[0..0] of longint;    { variable size array of longint numbers}
        LongArrayPtr = ^LongArray;            { GetDefaultData: Index [0] is reserved. First valid index is [1].}
        LongArrayHandle = ^LongArrayPtr;        { Handle to an array of longint numbers }
        LongArrayHandlePtr = ^LongArrayHandle;


{ ************ type definitions for "GetColHandle/SetColHandle" ************** }
        StringData = record                { the data structure of a column of strings. Warning: this data structure may change in future releases of pro Fit    }
                size: longint;                { the size of valid data in this handle     }
                nrRows: longint;                { the number of rows in this handle     }
                firstOffset: longint;            { reserved     }
                firstRow: integer;            { reserved     }
                data: Str255;                { here follow the strings, packed, one after another }
            end;




        checkPAnswer = (update, good, bad);                { the possible return values of the 'check' function, only used when the external module is a function             }

        ModeType = (active, inactive, constant);            { the fitting state of a parameter, used to set variables of type ParamMode            }
        ParamName = string[maxParamNameLength];

        ParamArray = array[1..maxNrParams] of extended;        { the numerical values of the parameters             }
        ParamNameArray = array[1..maxNrParams] of ParamName;    { the names of the parameters }
        ParamModeArray = array[1..maxNrParams] of ModeType;    { the fitting modes of the parameters, {active, inactive, constant)  }


        DefaultParamInfo = record
                value: ^ParamArray;                { the default value of the parameters as they appear in params window             }
                lowest: ^ParamArray;                { the lowest allowed value (for fitting)             }
                highest: ^ParamArray;                { the highest allowed value (for fitting)             }
                mode: ^ParamModeArray;            { the fitting mode of the parameters             }
                name: ^ParamNameArray;            { the names             }
            end;

        DefaultParamInfoPtr = ^DefaultParamInfo;

        GlobalArrayType = array[0..99] of extended;
        GlobalArrayPtr = ^GlobalArrayType;
        GlobalArrayHandle = ^GlobalArrayPtr;

        GlobalScratch = record
                globalScratch1: longint;                { free for use in external modules             }
                globalScratch2: longint;                { free for use in external modules             }
                globalDataSize: longint;                { the number of entries in the following array             }
                globalData: GlobalArrayHandle;            { array of extendeds to be accessed by external and interal programs             }
            end;

        GlobalScratchPtr = ^GlobalScratch;

{$ALIGN RESET}


{ ******************************************************************************************* }
{ ************************* parameter block for external modules **************************** }

{ The following is interface information that defines the communication between                            }
{ an External Module and pro Fit. This information is used in the implementation part                            }
{ to provide the code that implements all of the predifined routines made                            }
{ available by pro Fit.                                                                    }

{ Normally, you will just want to leave this information untouched in its present form    }
{ and to never have a look at it.                                                }


{                             ************************                            }


{ You need the folloing information if you want to program a very advanced                            }
{ external module, and if you want to do more exotic things.                                    }

{ All the interaction between pro Fit and the external module takes place through the procedure main.                            }
{ pro Fit calls it with different values of its parameter 'selector' and the                            }
{ function main must return the information requested by setting the necessary fields                            }
{ inside a parameterBlock.                                                                }

{ When it first opens the external module, pro Fit calls main with the selector equal to zero, and                            }
{ main must provide the specifications of the code supplied, such as the settings                            }
{ with which the code was compiled, if the code is a function or a program, the name of the                            }
{ external module, etc.                                                                        }

{ Depending on the response it obtains after calling the external module with selector 0, pro Fit                            }
{ then calls it with the selector that tells the module to initialize some parameters. This is                            }
{ very simple for programs, but there are a few more things to be set for functions.                            }

{ After the module is added to pro Fit's menus pro Fit calls it with the selector                            }
{ identifying the action needed and pro Fit will expect the external module to react accordingly.                            }
{ For programs, pro Fit calls the external module with only one selector, the one identifying                            }
{ the function run().                                                                        }
{ For functions, pro Fit calls the external module with a range of selectors, identifying the                            }
{ functions check, first, last, and so on. If you do not want to define such functionality, simply                            }
{ leave these function empty.                                                                        }

{ See the files FunctionTemplate.p and ProgramTemplate.p                                    }
{                                        }
{ *****************************************************************************************                            }



{     The following record is used as a parameterBlock when pro Fit calls an external module.                            }
{     The external module must provide a function main(selector:integer; pb: ExtModulesParamBlockPtr).                            }
{     When pro Fit interacts with the external module, it calls main with various values of the                             }
{     first parameter. Depending on the value of selector the function main must give the                            }
{     right response, i.e act as the function first, or calculate the y-value or your                            }
{     functions, and so on. The parameterblock contains all the information you will ever need                            }
{     to do this.                                                                            }

{     The template files for functions and programs provide a predifined function main that                 }
{    performes all the necessary calls, with the right parameters, to a set of functions                     }
{    called, as you might expect, first, check, derivatives, run, etc.                                 }
{    These functions correspond exactly to the functions you                                        }
{     define when defining functions and programs within pro Fit.                                        }

{     All you need to do is fill them in according to your needes.                            }

{     Unless you want to produce some advanced, exotic functionality in your external module, you                            }
{     do not need to access the parameter block directly.                                            }
{     WARNING: the definition of ExtModulesParamBlock may change in future versions                             }
{     of pro Fit. Using it from within your function may cause compatibility problems                             }
{     with those future versions.                            }

    const
{constants used to set the fields in the ExtModulesParamBlock defined below             }
        CPU68noFPU = 1;                {constants for codeType            }
        CPU68FPU = 2;
        CPUPowerPC = 3;

        kSetup = 0;                    {constants for selector            }
        progInitialize = 11;
        progRun = 12;
        funcInitialize = 21;
        funcCheck = 22;
        funcFirst = 23;
        funcFunc = 24;
        funcDerivatives = 25;
        funcLast = 26;
        kCleanUp = 31;

    type

{$ALIGN MAC68K}
        ExtModulesParamBlock = record  {parameter block used for the communication to and from proFit            }

                RunTimeProcPtr: Ptr;    {    call back routine for proFit            }
                        {    the external module uses this bottleneck to call all routines             }
                        {    provided by proFit             }
                globals: Ptr;        {     global variable space (defined if selector>0) and if requiredGlobals was set >0 in SetUp. }

    { parameters to be set when selector=ksetup             }
                versionNumber: integer;        { the present implementation             }
                moduleKind: integer;            { isFunction, isProgram, isMacro             }
                codeType: integer;            { CPU68noFPU=1, CPU68FPU, CPUPowerPC             }
                name: Str255;                { the name of your external module             }
                requiredGlobals: longint;        { global memory required. If this is >0 proFit will allocate the             }
                                { required memory for you and return a pointer to it in the pointer             }
                                { globals. Do not touch the pointer value. proFit is responsible             }
                                { for allocating AND deallocating it.             }


    { general info provided by proFit             }
                v: array[1..30] of extended;    { an array for general purpose your use in the external module             }

{ the following entries can only be used by when the external module is a function.             }
{ they can be accessed only when selector>0 and when             }
{ moduleKind==isFunction. moduleKind must be set when the external module             }
{ is called for the first time (with selector==0)             }

    { parameters to be set by funcInitialize             }
                dummy: Boolean;                 { unused             }
                hasDerivatives: Boolean;        { true if proFit must call the function "Derivatives" defined in your module }
                                { You can set this paramter to true, and only calculate a few derivatives (dyda[] values) }
                                { in your "Derivatives" function. pro Fit will take care of calculating the rest numerically. }
                                { If you set this hasDerivatives to true and leave your definition of "Derivatives" empty, then }
                                { you have the same result obtained when setting hasDerivatives to false: proFit calculates all }
                                { derivatives numerically. }
                descr1, descr2: Str255;        { description to appear in parameters window             }
                numberOfParams: integer;        { number of parameters used by the function             }
                a0: DefaultParamInfo;            { all parameter default settings             }

    { parameters used in check:             }
                paramNo: integer;            { current parm number, for check (0..maxNrParams-1)     }
                answer: integer;                { return value of check, type CheckPAnswer             }

    { parameters used in func and in derivatives             }
                x, y: ^extended;                    { x- and y-value             }
                a: ^ParamArray;                    { parameter values, set to a0.value before calling first             }
                dyda: ^ParamArray;                { used by derivatives, set to the derivatives of the function with respect to its parameters.}
                                    { If a dyda[] value is not set, pro Fit calculates that derivative numerically.}
                globalScratch: GlobalScratchPtr;    { global data to be acessed by all modules             }
                moduleFile: FSSpec;                { the file where this external module is in             }
            end;

        ExtModulesParamBlockPtr = ^ExtModulesParamBlock;
        ExtModulesParamBlockH = ^ExtModulesParamBlockPtr;


{$ALIGN RESET}



{*****************************************************************************************            }
{*****************************************************************************************            }
{*****************************************************************************************            }

{              Declarations of all routines provided by pro Fit.                                }
{                                                                                     }
{ For an explaination of the meaning of the various parameters and the return values see                 }
{ the pro Fit user manual .                                                                 }



{******************************************************************************            }
{********************************* input/output *******************************            }

    function InputBox (nrArgs: integer; var r: inputRec): boolean;
{ Shows a dialog box with nrArgs (between 1 and 6=maxNrInputValues) input values }
{ r contains a title and a numeric field for every argument }
{ The default way to display an input value is an numberic edit field with a title }
{ If the title 'ttt' starts with a '$' other interface elements are displayed: }
{ - '$Wttt' shows a popup menu to select a data window }
{ - '$Cttt' shows a popup menu to select a column }
{ - '$Pmmm$ttt' shows a user defined popup menu 'mmm' (each entry separated by a ';') }
{ - '$Xttt' shows a check box }
{ - '$Sttt' shows an edit field to input a string }
{ returns true if stop, false otherwise }

    function AlertBox (s: str255): boolean;
{ shows an alert box with message s and two buttons (OK,  STOP)             }
{ returns true if stop, false if ok             }

    procedure SetBoxTitle(title: Str255);
{ Sets the title of the dialog box in the next call to InputBox. }
{ By default, this box does not have a title. }

    function AskBox (var answer: integer; s: str255): boolean;
{ shows alert box with message s and three buttons (YES, NO, STOP)             }
{ returns true if stop, else false             }
{ if not stop, answer = 0 for no and 1 for yes             }

    procedure WriteString (s: Str255);
{ writes s into the results window             }

    procedure WritelnString (s: Str255);
{ writes s into the results window and goes to a new line             }

    procedure WriteText (length: longint; theText: Ptr);
{ writes a text to the results window. the pointer theText points to the first }
{ character of the text. "length" must give the length of the text            }

    procedure WriteInt (i: longint);
{ writes an integer value to the results window             }

    procedure WriteNumber (d: extended);
{ writes a floating point value to the results window             }

    procedure NumberToStr255(x: extended; var s: Str255; format, digits:integer);
{ converts the number x into a string }
{ format/digits: controls the conversion process. }
{    format = 0:         normal conversion }
{                    if digits>0: the number of digits after the '.', }
{                    if digits<0: the total number of digits (approx.) }
{  format = 1:        optimized conversion, removes unnecessary trailing zeros after }
{                    the decimal point, leading spaces, unecessary '+'-signs, etc }
{                    digits: the number of digits }

    function Str255ToNumber(s: Str255; var x: extended):integer;
{ converts string s to a number x. s can be a numeric string or an expression }
{ return values: }
{    0:        conversion successful }
{    1:        x is infinite }
{    2:        s is empty }
{    3:        x is an NAN (invalid number) }
{    4:        user aborted calculation }
{    5:        run time error }


{******************************************************************************            }
{*********   redirecting text to the results window or to text files **********            }


    function CreateTextFile (fileName: Str255): longint;

{        creates a text file with the given name and returns a                                    }
{        reference number used to identify this file.                        }
{        Call the routine WriteToTextFile() to redirect the                        }
{        output from calls to write/writln/writenumber into this file.                        }


    procedure CloseTextFile (fileRefNumber: longint);

{        Closes the text file with the given reference number.                         }
{        The calls to write/writln/writenumber is redirected back to                        }
{        the results window.                        }


    procedure WriteToTextFile (fileRefNumber: longint);

{        redirects the output of the pro Fit "write/writeln/writenumber"                        }
{        routines to the given text file.                        }
{                                 }
{        call this routine with fileRefNumber==0 to direct the text                        }
{        writing routines back to the results window.                        }




{******************************************************************************                        }
{*************** window and document management routines **********************                        }

    function GetFrontWindow: longint;

{        Returns the identification number of the frontmost window                        }


    procedure DoNewWindow (windowType: OSType);

{        creates a new window. windowType can take one of the following values:                        }
{            drawingType:    create a drawing window                        }
{            dataType:        create a data window                        }
{            textType        create a text window                        }


    procedure SetCurrentWindow (windowID: longint);

{        makes the window with the given ID number the current window to                        }
{        be used for data, plotting, writing, etc, depending on its type.                        }


    function GetCurrentWindow (windowType: OSType): longint;

{        returns the ID number of the current window of the given type                        }
{        windowType can take one of the following values                        }
{            drawingType:    return the current drawing window                        }
{            dataType:        return the current data window                        }
{            textType        return the current text window                        }


    procedure DoCloseWindow (windowID: longint; saveIt: Boolean);

{        closes the window with the given ID number.                        }
{        saves the contents of the window if saveIt is true                        }


    function FrontmostWindow (windowType: OSType): longint;

{        returns the ID number of the front most window with the given type                        }
{            drawingType:    return the frontmost drawing window                        }
{            dataType:        return the frontmost data window                        }
{            textType        return the frontmost text window                        }


    procedure SaveWindow (windowID: longint);

{        saves the contents of the given window in the file associated with it                        }


    procedure SaveWindowAs (windowID: longint; fileName: Str255);

{        saves the contents of the given window in the file.                        }
{        fileName: the files name. If fileName does not contain a file path, the file                        }
{            is expected to reside in the same folder as pro Fit. Alternatively, you                        }
{            can specify a file path, such as "\pHD:MyFolder:My File".                        }
{            if fileName is an empty string, the window is saved in a file having the name of the window                        }
{            if fileName is '?', a dialog box is brought up to ask for user for a name                        }


    function GetWindowID (windowName: Str255): longint;

{        returns the ID number of the window with the given name.                        }
{        returns 0 if no such window is found.                        }


    function GetWindowType (windowID: longint): OSType;

{        returns the type of the window with the given ID number                        }
{        returns 0 if the given window is not a text, drawing or data window                        }
{                  or if there is no window exists with the given ID number                        }


    function NextWindow (windowID: longint): longint;

{        returns the ID number of the window immediately behind the given window                        }
{        returns 0 if the given window is the last one                        }
{        returns the front window if 0 is passed for the windowID.                        }
{        returns 0 and causes run-time error if the windowID it receives is invalid                        }


    procedure OpenFile (fileName: Str255);

{        Opens the given file in a new window.                        }
{        fileName: the files name. If fileName does not contain a file path, the file                        }
{        is expected to reside in the same folder as pro Fit. Alternatively, you                        }
{        can specify a file path, such as "\pHD:MyFolder:My File".                        }
{        Set name to '?' for bringing up a dialog box prompting the user for the name.                        }
{        A run-time error occurs if the file cannot be opened.                        }


    procedure OpenData (fileName: Str255);

{        Opens the given file as a data file. The file must either be a pro Fit data                        }
{        file or a text file with valid data.                        }
{        fileName: the files name. If fileName does not contain a file path, the file                        }
{        is expected to reside in the same folder as pro Fit. Alternatively, you                        }
{        can specify a file path, such as "\pHD:MyFolder:My File".                        }
{        Set name to '?' for bringing up a dialog box prompting the user for the name.                        }
{        A run-time error occurs if the file cannot be opened.                        }


    procedure OpenText (fileName: Str255);

{        Opens the given file as a text file. The file must either be a pro Fit function                        }
{        file or a text file.                        }
{        fileName: the files name. If fileName does not contain a file path, the file                        }
{        is expected to reside in the same folder as pro Fit. Alternatively, you                        }
{        can specify a file path, such as "\pHD:MyFolder:My File".                        }
{        Set name to '?' for bringing up a dialog box prompting the user for the name.                        }
{        A run-time error occurs if the file cannot be opened.                        }


    procedure SetTextFileFormat (colDelimiter, endOfLine: Str255; withColTitles, copyInfoText: Boolean; nrHeaderLines, inputORoutput: longint);

{        colDelimiter:    inserted between consecutive cells in the same row.                        }
{                        Usually, you will specify a tab character by passing "\p\t"                        }
{        endOfLine:        inserted between the last cell of a row and the first cell                        }
{                        of a next row. Usually, you will specify the CR character                        }
{                        by passing "\p\15"                        }
{        withColTitles:    pass true if the column titles should be saved / loaded                            }
{                        as the (first) row of the file.            }
{        copyInfoText:    pass true if the text in the info field of the data window                        }
{                        shall be saved / loaded.                }
{        nrHeaderLines:    number of header lines contained in the text file when loading.                    }
{                        If copyInfoText is true, these lines are copied to the info                        }
{                        field, otherwise they are skipped.        }
{        inputORoutput:    pass 1 to define the format of the input file (loading),                        }
{                        pass 0 to define the format of the output file (saving).    }


    procedure SaveDataAsText (windowID: longint; fileName: Str255);

{        saves the contents of the data window in a file.                        }
{        fileName: the file's name. If fileName does not contain a file path, the file                        }
{            is expected to reside in the same folder as pro Fit. Alternatively, you                        }
{            can specify a file path, such as "\pHD:MyFolder:My File".                        }
{            if fileName is an empty string, the window is saved in a file having the name of the window                        }
{            if fileName is '?', a dialog box is brought up to ask for user for a name                        }
{        The individual cells will be stored row by row.                        }


    procedure SaveDrawingAs (windowID: longint; fileName: Str255; format: longint);

{        saves the contents of the drawing window in a file.                        }
{        fileName: the file's name. If fileName does not contain a file path, the file                        }
{            is expected to reside in the same folder as pro Fit. Alternatively, you                        }
{            can specify a file path, such as "\pHD:MyFolder:My File".                        }
{            if fileName is an empty string, the window is saved in a file having the name of the window                        }
{            if fileName is '?', a dialog box is brought up to ask for user for a name                        }
{        format:    0 for saving the file in a standard pro Fit drawing file                        }
{                1 for saving the file as picture (having a file type PICT)                        }
{                2 for saving the fiel as eps-file (having a file type EPSF)                        }


    procedure SetWindowTitle (windowID: longint; name: Str255);

{        sets the title of a given window. The title should not contain a ':'                        }


    procedure GetWindowTitle (windowID: longint; var name: Str255);

{        returns the title of the window with the given windowID                        }


    procedure SetWindowInfo(windowID:longint; length: longint; info: Ptr);
{        Sets the info of a window. (The "info" of a window can be viewed by using the }
{        Get Info... command from the File menu. For data windows, it is the }
{        text that appears when you drag down the info field.) }
{        windowID: the id of the window }
{        length: the length of the text in bytes }
{        info: a pointer to the start of the text }
{        Use SetWindow(windowID, 0, nil) for clearing the info field. }


    procedure PlaceWindow (windowID: longint; windowRect: Rect);

{        resizes and positions the window according to windowRect                        }



    procedure BringWindowToFront (windowID: longint);

{        the window with the given ID number is brought in front of all others.                        }


    procedure Compile (windowID: longint);

{        Compiles the text found in the given window.                        }
{        Causes a run error if the given window is not a function window or if                        }
{        the text is not compiled successfully.                        }




{******************************************************************************                        }
{************************* drawing and plotting *******************************                        }


    procedure OpenCurve (curveName: Str255);

{        Starts a new function curve definition in the current graph. After this call,                        }
{        all moveto/lineto calls will generate lines in the current graph.                        }
{        The function curve will use the current style/color, set by SetLineStyle/SetLineColor                        }
{        curveName is the name that will appear in the legend (pascal string).                        }
{        Call CloseCurve once you are finished.                        }

{        This function replaces the obsolete "NewCurve" function, used in earlier versions                        }
{                                }


    procedure CloseCurve;

{        Matches the "OpenCurve" call. Stops collecting moveto/lineto calls                        }
{        as a definition of a function curve in the current graph.                        }
{        Call once you are finished defining a curve in the current graph.                        }



    procedure OpenDataSet (errors: integer; connected: Boolean; datasetName: Str255);

{        Starts a new data set definition in the current graph. After this call,                        }
{        all DrawDataPoint calls will generate data points in the current graph.                        }
{        AddDataPoint is also used for the same purposes, if you want to add error                        }
{        bars to the data point.                        }
{        The data set will use the current style/color, set by SetLineStyle/SetLineColor                        }
{        datasetName is the name that will appear in the legend.                        }
{        Call CloseDataSet once you are finished.                        }
{        errors:        used to specify if the new data set will use error bars or not.                        }
{                    pass 0 if you don't plan to use error bars,                        }
{                    pass a sum of eBarY, eBarX, asymmEBarY, asymmEBarX to specify which                        }
{                    kind of error bars you will use.                        }
{        connect:    set to true if you want a line to coonnectthe data points.                        }
{                                }
{        Example                        }
{            "eBarY+asymmEBarX" tells proFit that it has to allocate space for                        }
{            holding the value of the y error bar and the two values corresponding                        }
{            to the left and right part of an x error bar.                        }
{            When you then call AddDataPoint, the parameters yErr, xErr, and xErr1                        }
{            will be interpreted by proFit.                        }
{                                }
{        This function replaces the obsolete "NewDataSet" function, used in earlier versions                        }




    procedure CloseDataSet;

{        Matches the "OpenDataSet" call. Stops collecting AddDataPoint/DrawDataPoint calls                        }
{        as a definition of a data set in the current graph.                        }


    procedure SetCurveFill (whichAxis: integer; axisID: integer);

{        switches on the filling style for curves that will be created in the current                        }
{        graph using the OpenDataSet and OpenCurve functions.                        }
{        the parameters to this routine specify the axis towards which the filling is                        }
{        applied. use axisID==0 to swich off filling.                        }
{        Specify the filling color using the "SetFillColor" routine.                        }


    procedure SetEBarStyle (caplength, capThick, lineThick: extended);

{        sets the default error bar style used for producing error bars in the next                        }
{        data set created in the current graph using the OpenDataSet call                        }


    procedure AddDataPoint (x, y, xErr, yErr, xErr1, yErr1: extended);

{        Adds a data point at the given coordinates and with the given error to the                        }
{        current data set in the current graph.                        }
{        The error-parameters are interpreted in the way specified by setting the                        }
{        "errors" parameter in the NewDataSet call.                        }

{        If you don't use error bars you can call the "DrawDataPoint" routine instead of AddDataPoint                        }


    procedure GrMoveto (x, y: extended);

{ Moves the pen to position x,y of the current graph without drawing anything                         }
{ x,y are in coordinates of the current graph                         }

    procedure GrLineto (x, y: extended);
{ Draws a line between the current pen position and position x,y of the current graph                         }
{ x,y are in coordinates of the current graph                         }

    procedure GrMove (x, y: extended);
    {                         }
{        add x, y to the current point.                        }


    procedure GrLine (x, y: extended);
    {                         }
{        add a line starting from current point                        }



    procedure GetGraphCoordinates (var xmin, xmax, ymin, ymax: extended);
{ Returns the minimum and maximum x- and y-coordinates of the current graph in                         }
{ the variables xmin, xmax, ymin, and ymax                         }

    procedure CreateNewGraf (xmin, xmax, ymin, ymax: extended; xScaling, yScaling: integer);
{ creates a new , empty graf with the given ranges produces a run - time error                        }
{if no drawing window is available or if the ranges are inconsistent                         }
{    xScaling/yScaling     = 0    : linear                                }
{                            = 1    : log                                }
{                            = 2    : 1/x                                }
{                            = 3    : probability                                }

    procedure SetLineStyle (thick: extended; dash: integer);

{        Sets the default line style that will be used for drawing and plotting.                        }
{        thick:    the thickness of the line in points,                        }
{        dash:    the dash pattern, given by the item number in the dash popup menu                        }


    procedure SetFillPattern (pattern: integer);

{        Sets the default fill pattern.                        }
{        pattern:    the fill pattern, given by the item number in the corresponding popup menu                        }


    procedure SetArrowStyle (arrowLocation: integer; style: integer; size: extended);

{        Sets the default arrow style.                        }
{        You can define different arrows for line start and line end.                        }
{        arrowLocation:    1: at start, 2: at end, 3: both start and end                        }
{        style:            0: no arrow, 1..12: the item number in the arrow popup menu.                        }
{        size:            the size of the arrow in points, as it would appear in the custom arrow dialog box.                        }


    procedure SetTextStyle (fontName: Str255; size: extended; style: integer);

{        Sets the default text style.                        }
{        supply a font name, its size, and style.                        }
{        size and style are the same parameters you can pass to the MacOS routines "TextSize" and "TextFace"                        }


    procedure SetNewGraphRect (left, top, right, bottom: extended);

{        Sets the default rectangle used for creating new graphs in the drawing window.                        }


    procedure SetDataPointStyle (style: integer; size: extended; thickness: extended);

{        Sets the default data point style.                        }
{        style gives the item number in the data points popup menu                        }
{        style:    0:pixel, 1-13: row number in data pont menu, 14-17: points in the last row, second column                        }
{                -1..-8: the 8 custom points in the separate section                        }
{        size:    the size of the point in points, same as the one which is given in the custom data point symbols dialog box.                        }
{        thickness:    the line thickness used to draw empty data point symbols.                        }


    procedure SetBGDataPointStyle (style: integer; size: extended);

{        Can be used in conjunction with SetDataPointStyle to set the default data pont style.                        }
{        Substitutes the background symbol of the current data point style with the one                        }
{        given.                        }
{        supply a font name, its size, and style.                        }
{        size and style are the same parameters you can pass to the MacOS routines "TextSize" and "TextFace"                        }



    procedure SetLineColor (red, green, blue: longint);

{        Sets the default line color, used for lines and text.                        }
{        red, green, blue give the RGB value of the color (0<red,green,blue<65536)                        }


    procedure SetFillColor (red, green, blue: longint);

{        Sets the default fill color, used to fill drawing shapes or for curves in plots.                        }
{        red, green, blue give the RGB value of the color (0<red,green,blue<65536)                        }


    procedure DrawRect (left, top, right, bottom: extended);

{        Creates a rectangle with the given coordinates in the current drawing window                        }


    procedure DrawEllipse (left, top, right, bottom: extended);

{        Creates an ellipse with the given coordinates in the current drawing window                        }


    procedure DrawLine (start_h, start_v, end_h, end_v: extended);

{        Creates a line with the given coordinates in the current drawing window                        }


    procedure DrawTextLine (theString: Str255; theAngle: extended; docenter: Boolean);

{        Creates a text-label at the given coordinates in the current drawing window                        }
{        with the given rotation angle.                        }
{        rotation is around center if docenter is true.                        }


    procedure DrawNumber (theNum: extended; decs: integer; theAngle: extended; docenter: Boolean);

{        Converts the number into a text with the given number of decimals; and                        }
{        creates a text-label at the given coordinates in the current drawing window;                        }
{        with the given rotation angle.                        }
{        rotation is around center if docenter is true.                        }


    procedure DrawDataPoint (x, y: extended);

{        Draws a data point symbol at the coordinates given, using the current             }
{        data point style.            }
{        if OpenDataSet was called, then it creates a data point in the current plot,            }
{        adding it to the current data set.            }
{                }

    procedure DrawPICT (left, top, right, bottom: extended; thePict: PicHandle);

{        Creates a new picture in the current drawing window using the             }
{        MacOS PicHandle "thePict".                        }
{        Once you call this routine, the handle thePict BECOMES PROPERTY         }
{        of pro Fit — DO NOT DISPOSE IT!                        }
{        left and top give the coordinates of the picture.            }
{        right and bottom are used to define the size of the picture if they are larger            }
{        than left and top, respectively.            }
{        Otherwise the size information containd in the PicHandle passed you pass is used.            }
{                }

    procedure GetLastClickedCoordinates (var x, y: extended);

{        returns the screen-coordinates that were last clicked by the user            }
{                }


    procedure DisableDrawingUpdates;

{        Inhibits updates in the current drawing window until your program is finished.            }
{        Call this if you are drawing lots of stuff and you want to do it as fast as            }
{        possible.            }
{                }

    procedure OpenPolygon (smoothing: integer; kind: integer);

{        Opens a new polygon definition, which can then be defined by moveto/lineto calls.            }
{        smoothing:    gives the kind of smoothing which is applied to the polygon, use            }
{                    0 for no smoothing.            }
{        kind:        0 for a normal polygon, 1 for a closed polygon.            }
{                }

    procedure ClosePolygon;

{        Stops collecting data for a polygon definition, and creates the resulting            }
{        polyon in the current drawing window.            }
{                }


    procedure GroupBegin;
    procedure GroupEnd;

{        Starts/ends the definition of a group. All drawing taking place after this call            }
{        will be part of a group.             }
{        Call GroupEnd when you are finished with the drawing that belongs to this group.            }
{                }


    procedure SetCurrentGraph (graphID: longint);

{        Sets the current graph, that is the graph that will be used for all newly            }
{        created function-curves and data-sets, and by all routines that access the            }
{        current graph in general, such as the axes-editing routines.            }
{        graphID is the graph's identificatioin number, which can be found immediately            }
{        after a graph is created by using the routine GetCurrentGraph.            }
{                }

    function GetCurrentGraph: longint;
    {                }
{        returns the graph identification number of the current graph.            }
{                }


    function GetNextGraph (graphID: longint): longint;

{        returns the identification number of the graph following the given one in            }
{        pro Fit's private list of existing graphs. The order in this list is not            }
{        defined and depends on the order of the windows containing the graphs.            }
{        use graphID=0 to get the ID of the first graph.            }
{        returns 0 if graphID identifies the last graph, or if graphID!=0 and no graph             }
{        with this identification number exists.            }
{                }

    procedure GetGraphFrame (var left, top, right, bottom: extended);

{        returns the coordinates of the frame of the current graph.            }
{                }

    procedure SetGraphFrame (left, top, right, bottom: extended);

{        changes the frame of the current grapha to match the given coordinates.            }
{                }



    function GetCurrentAxis (whichAxis: integer): integer;

{        returns the number of the current x or y axis.            }
{        whichAxis is either xAxis (==0) or yAxis (==1).            }
{                }

    procedure SetCurrentAxis (whichAxis: integer; axisID: integer);

{        sets the current axis that will be used for the next data set or curve, and            }
{        for all axis-editing calls, such as SetRange, SetAxisPosition, etc.            }
{                }

    procedure DeleteAxis (whichAxis: integer; axisID: integer);

{        deletes the given axis in the current graph.            }
{                }

    procedure MakeNewAxis (whichAxis: integer; min, max: extended; scaling: integer; position: extended);

{        creates a new axis with the given range and scaling in the current graph.            }
{        position gives the position of the new axis in the coordinate system of the            }
{        MAIN AXIS perpendicular to it.            }
{                }

    procedure SetRange (whichAxis: integer; min, max: extended; scaling: integer);

{        Changes the range and scaling of the current axis to the specified one.            }
{        (the current axis can be set with the SetCurrentAxis routine)            }
{                }

    procedure MakeTicks (whichAxis: integer; firstMaj, distance: extended; nrMinTicks: integer);

{        Lets the current axis recalculate its ticks, based on the new position            }
{        of the first major tick, tick distance, and number of minor ticks.            }
{                }

    procedure SetLabelsFormat (whichAxis: integer; format: integer; decimals: integer);

{        Changes the format of the tick labels of the current axis.            }
{        format:        -1: auto, 0: decimal, 1: auto exponent.            }
{                    any other number gives the fixed exponent            }
{        decimals:    number of digits after the decimal point.            }
{                }

    procedure ClearLabels (whichAxis: integer);

{        Clears the text contained in all labels of the current axis.            }
{                }

    procedure ClearTicks (whichAxis: integer);

{        Clears the ticks list of the current axis, effectively creating            }
{        an empty list of ticks.            }
{        Call this routine before defining a set of custom ticks with the            }
{        AddTick routine.            }
{                }


    function AddTick (whichAxis: integer; tickPos: extended; isMajor: Boolean): integer;

{        Use this routine to define your own ticks in the current axis.            }
{        Call ClearTicks before using this routine.            }
{        given the position of the tic mark and its properties (set isMajor to true            }
{        to obtain a major tick), AddTick returns the index of the newly created            }
{        tick in the tick list.            }
{        It returns 1 for the first tick.            }
{        This index can be used in the SetLabel/SetLabelText routines to change            }
{        the label attached to the newly created tick.            }
{                }

    procedure SetLabel (whichAxis: integer; tickNum: integer; labelNumber: extended);

{        Given a tick index (1<=tickNum<=numberOfTicks), this routine attaches the            }
{        given label to it by converting labelNumber into a string according to            }
{        the label-format specified for the current axis.            }
{        labels can be attached to minor or major ticks in the same way.            }
{                }

    procedure SetLabelText (whichAxis: integer; tickNum: integer; labelText: Str255);

{        Given a tick index (1<=tickNum<=numberOfTicks), this routine attaches the            }
{        given label to it by using the text passed in labelText (pascal string!)            }

{                }

    procedure SetAxisPosition (whichAxis: integer; position: extended);

{        Sets the position of the current axis in the coordinate system of the            }
{        MAIN AXIS perpendicular to it.            }
{                }


    procedure SetAxisAttributes (whichAxis: integer; flags: longint);

{        sets the attributes of the current axis to match "flags"            }
{        flags:    a set of axis characteristics that can be calculated by summing the            }
{                available constants.            }
{                }


    procedure SetGraphAttributes (flags: longint);

{        sets the attributes of the current axis to match "flags"            }
{        flags:    a set of axis characteristics that can be calculated by summing the             }
{                available constants.            }
{                }





{******************************************************************************            }
{**************** interaction with other functions and programs ****************            }


    procedure SetParamLimits (paramNum: integer; low, high: extended);
{ sets the limits of a parameter (of the currently running function)             }

    procedure SetParamDefaultValue (paramNum: integer; value: extended);
{ sets the name of a parameter (of the currently running function)             }

    procedure SetParamName (paramNum: integer; s: str255);
{ sets the name of a parameter ( of the currently running function )             }

    procedure SetParamDefaults (paramNum: integer; value: extended; mode: modeType; name: Str255; low, high: extended);
{ sets the default settings of a parameter (of the currently running function)             }
{ mode is (active, inactive, constant)             }


    function CallFunction (name: Str255; xvalue: extended): extended;
{ calls any of the functions in the func menu by its name             }

    function GetNumFunctionParams (functionName: Str255): integer;
{ returns the number of parameters of a function in the func menu             }

    function GetFunctionParamMode (functionName: Str255; paramIndex: integer): modeType;
{ returns the mode of a parameter of a function in the func menu             }

    procedure GetFunctionParamName(functionName: Str255; paramIndex: integer; var paramName: Str255);
{ returns the name of a parameter for one of the functions in the func menu }

    function GetFunctionParam (functionName: Str255; paramIndex: integer): extended;
{ returns the parameter of a function in the func menu             }

    procedure SetFunctionParam (functionName: Str255; paramIndex: integer; value: extended);
{ sets the parameter of a function in the func menu             }

    procedure CallProgram (name: Str255);
{ calls a program from the User menu             }

{******************************************************************************            }
{***************************** numerical analysis *****************************            }

    function Integral (functionName: Str255; xmin, xmax: extended; numIters: integer): extended;
{ calculates the integral of a function in the func menu             }

    function Maximum (functionName: Str255; xmin, xmax: extended): extended;
{ finds the maximum of a function in the func menu             }

    function Minimum (functionName: Str255; xmin, xmax: extended): extended;
{ finds the minimum of a function in the func menu             }

    function Root (functionName: Str255; xmin, xmax: extended): extended;
{ finds the root of a function in the func menu             }
    function Derivative (functionName: Str255; x, scale: extended): extended;
{ finds the root of a function in the func menu             }
{ at the ascissa value x. scale is a typical scale over which the function changes.            }
{ This number is not necessarily small!            }

    procedure Fit (functionName: Str255; xCol, yCol, errCol: longint; errVal: extended; selectionOnly: Boolean);
{ runs a non-linear fit for the given function. Generates a run-time             }
{ error if fit did not converge.             }
{ xCol, yCol: the x- and y-columns             }
{ errCol: the error column. Set to 0 if using no error or a constant / percentual error             }
{ errVal:    if > 0: a constant error   if < 0 (-100..-0) a percentual error             }
{ selectionOnly: set to true if only selected rows should be fitted             }

    function ChiSquared: extended;
{ returns the chi - squared of the last successful fit . Produces a run - time error            }
{ if no fit information from a successful fit is available             }

    function NumFitParams: integer;
{  returns the number of parameters of the last successful fit             }
{( ALL parameters , active , inactive , and constant returns 0            }
{if no fit information from a successful fit is available              }

    function FittedParams (paramNum: integer): extended;
{returns the fitted value of a parameter . Produces a run - time error            }
{if no fit information from a successful fit is available             }

    function ParamSD (paramNum: integer): extended;
{returns the standard deviation of a parameter after a successful fit .            }
{ returns NAN ( Not A Number , an invalid real number )if no standard deviation             }
{is available . Produces a run - time error if no fit information from a successful fit             }
{is available              }

    function CovarMatrix (paramNum1, paramNum2: integer): extended;
{returns the elements of the covariance matrix after a successful fit .             }
{returns NAN if the corresponding element is not defined because the parameter             }
{was not used for the fit . Produces a run - time error if no fit information from a             }
{successful fit is available             }

    function PRandom: extended;
{ Returns a random number between 0 and 1             }


    function NumberInvalid (aNum: extended): boolean;
{ returns true if the argument is not a good number             }
{ returns false if the argument is a normal, reasonable number             }


    function Erf (x: extended): extended;
    {                }
{        returns the error function defined as            }
{                 x            }
{          2      /            }
{        ------   |  exp(-t*t) dt            }
{          √π     /            }
{                 0            }
{        The definition is such that Erf(-inf) = -1, Erf(inf) = 1            }
{                }

    function Erfc (x: extended): extended;
    {                }
{        returns the complementary error function defined as 1-erf(x)            }
{                }

    function PErf( x: extended): extended;
{ same as Erf but with alternative name: erf() is also defined in fp.p - use PErf() to avoid conflicts }
    function PErfc( x: extended): extended;
{ same as Erfc but with alternative name: erfc() is also defined in fp.p - use PErfc() to avoid conflicts }


    procedure SetFitDefaults (algorithm: integer;        { algorithm to be used for fitting             }
                                    yErrDistribution: integer;     { y error distribution: gaussDistr, extendedExpDistr, lorentzDistr, andrewDistr, tukeyDistr             }
                                    xErrDistribution: integer;    { x error distribution: gaussDistr, extendedExpDistr, lorentzDistr, andrewDistr, tukeyDistr             }
                                    xErrColumn: longint;    { x error column: >0:column number, 0:none, -1:constant, -2:percent             }
                                    xErrValue: extended;            { x error value if constant (xErrColumn=-1) or percentage (xErrColumn=-2)             }
                                    stopTime: extended);            { criterium to stop monte carlo fits, does not stop if 0             }
                                                    { interpreted as seconds if negativ and as iterations if positive             }

{        Sets the error column and type, the algorithm and the stopping creteria            }
{        to be used in all subsequent calls to Fit(..)            }
{                }

    function Maximize (theFunction: Str255;            { the function name in the func menu             }
                                    precision: extended;                { relative tolerance of function values calculated in the simplex             }
                                            { algorithm, used as convergence criterium             }
                                    varyX: Boolean;                    { true, if the x-values should be varied, too             }
                                    var x, y: extended): Boolean;        { on input: fixed x-value, or starting x-value if varyX is true             }
                                            { returned x-value of maximum found             }
                                            { returned y-value of maximum found             }

{         Varies the parameters of the function (and x if varyX is true) until            }
{         the function value reaches a maximum. It is a procedure comparable to            }
{         fitting. The algorithm used is the Simplex method.             }


    function Minimize (theFunction: Str255; precision: extended; varyX: Boolean; var x, y: extended): Boolean;

{         See the comment for "Maximize", which works in the same way.             }


    procedure SetErrorAnalysis (confidence: extended;    { confidence interval in % (set to 0 to disable error analyis)             }
                                    iterations: longint);                { number of iterations (set to 0 to disable error analyis)             }

{         Sets the options for error analysis to be used in the next call to Fit(..)             }


    procedure ConfidenceInterval (i: integer; var min, max: extended);

{        returns in min,max the confidence interval for parameter i, as calculated after            }
{        the last fit by the error analysis algorithm.            }

{        Note that this routine does not return meaningful results if the confidence            }
{        interval for a given value was not determined, e.g. because this parameter            }
{        was not active during a fit.            }



    function CalcStat (column: longint;                { column number             }
                                    selRowsOnly: Boolean;         { set to true to use only the selected rows             }
                                    withBasics: Boolean;         { calculate basic information             }
                                    withSkewAndCurt: Boolean;     { calculate skewness and curtosis             }
                                    withMedian: Boolean): Boolean;        { calculate median             }

{        returns false if an error occurred, true if ok            }
{         set "column" to:  0 to include all columns.            }
{                         -1 to use the current selection            }
{        set the Boolean parameters corresponding to the information you            }
{        want to calculate.            }
{                    }
{        You will use GetBasics, GetSkew, GetMedian to retrieve this information            }
{                }

    procedure GetBasics (var count: longint;             { number of data processed             }
                                    var sum,             { sum of all these data                 }
                                    mean,             { their average                        }
                                    variance,        { variance = (stdDev)^2                }
                                    stdDev,            { the standard deviation                }
                                    meanAbsDev: extended);    { mean absolute deviation                 }

{        returns some results of the last statistics evaluation            }
{        CalcStat must have been called with the withBasics parameter            }
{        set to true before this function can be used.            }
{                }

    procedure GetSkewAndKurt (var count: longint;         { number of data processed             }
                                    var mean,         { 1st moment of distribution: average             }
                                            { measure the average value of a distribution             }
                                    variance,    { 2nd moment of distribution: variance             }
                                            { the square of the standard deviation             }
                                    skewness,     { 3d moment of distribution: skewness             }
                                            { characterizes the asymmetry of a distribution around its mean             }
                                    kurtosis: extended);    { 4th moment of distribution: kurtosis             }
                                            { measure the relative peakedness or flatness of a distribution             }

{        returns some results of the last statistics evaluation            }
{        CalcStat must have been called with the withSkewAndCurt parameter            }
{        set to true before this function can be used.            }
{                }


    procedure GetMedian (var count: longint;         { number of data processed             }
                                    var mean,         { average over all data             }
                                    median,        { the data in the midth of the ordered sequence of data             }
                                    minimum,     { smallest (largest negative) value found             }
                                    maximum: extended);    { largest value found             }

{        returns some results of the last statistics evaluation            }
{        CalcStat must have been called with the withMedian parameter            }
{        set to true before this function can be used.            }
{                }






{******************************************************************************            }
{************************ data access routines ********************************            }

    function XColumn: longint;
{ Returns the column number of the x column in the current data window. Returns zero if no            }
{x-Column is defined.            }

    function YColumn: longint;
{ Returns the column number of the y column in the current data window. Returns zero if no            }
{y-Column is defined.            }

    function XErrColumn: longint;
{ Returns the column number of the Δx colum in the current data window. Returns zero if no            }
{Δx-Column is defined.            }

    function YErrColumn: longint;
{ Returns the column number of the Δy colum in the current data window. Returns zero if no            }
{Δy-Column is defined.            }

    procedure SetDefaultCols (xColumn, yColumn, xErrColumn, yErrColumn: longint);
    {             }
{        Sets the default x, y, Δx, Δy columns of the current data window.             }
{        The default x and y columns are those columns that are shown in the             }
{        preview window.             }
{        Default columns are also identified by small x, y, Δx, Δy lettering in            }
{        the column header.            }
{        Set xErrColumn and yErrColumn to 0 to "undefine" it.            }
{        Use a negative number if you don't want to change a given default column.            }
{                }

    function NrRows: longint;
{ returns the number of rows in the current (frontmost) data window             }

    function NrCols: longint;
{ returns the number of columns in the current (frontmost) data window             }

    function GetData (Row, Column: longint): extended;
{ returns the value of the given cell of the data window             }

    procedure SetData (Row, Column: longint; ex: extended);
{ sets the value of the given cell of the data window             }

    function TestData (Row, Column: longint): boolean;
{ returns true if the value in the given cell of the data window is a number             }

    procedure ClearData (Row, Column: longint);
{ erases the value in the given cell of the data window             }

    function GetSelection: rect;
{ returns the selected cells of the data window, given by the row and column numbers (0 for no selection)             }

    procedure SetColName (Column: longint; s: str255);
{ writes s into the column title field of the data window             }

    procedure GetColName (var name: Str255; column: longint);
    { returns the name of a column in the current data window             }

    procedure SetDataSize (numberOfRows, numberOfColumns: longint);
    {              }
{        Resizes the current data window to match the new number of rows and columns            }
{        passed as a paramter.            }
{        Set a parameter to 0 if you don't want to change it.            }
{        Causes a run-time error if resizing fails.            }
{                }

    function GetColType (columnNumber: longint): longint;
    {              }
{        returns the type of a column of the current data window (colNumber = 1..MaxNrCols)            }
{        return values:            }
{            floatColumn:        4 byte floating point format            }
{            extendedColumn        8 byte floating point format            }
{            textColumn:            text format            }
{                }

    procedure SetColType (columnNumber: longint; theType: longint);
    {              }
{        sets the type of a column of the current data window (colNumber = 1..MaxNrCols)            }
{        theType:            }
{            floatColumn:        4 byte floating point format            }
{            extendedColumn        8 byte floating point format            }
{            textColumn:            text format            }
{        Causes a run-time error if conversion failed.            }
{                }

    function ColEmpty (columnNumber: longint): boolean;

{        returns true if the given column doesn't contain any data, false otherwise            }
{                }

    procedure SetColWidth (columnNumber: longint; width: integer);
    {                 }
{        sets the width of the given column to the number of pixels specified in "width"            }
{                }

    procedure SelectCells (left, top, right, bottom: longint);
    {              }
{        selects the cells within the given rectangle            }
{        the coordinates are clipped to the size of the data list            }
{                }


    procedure SelectRows (top, bottom: longint; doSelect: Boolean);
    {              }
{        selects or deselects the given rows            }
{        doSelect==true: selects the given rows            }
{        doSelect==false: deselects the given rows            }
{        top and bottom are clipped to the size of the list            }
{        selections outside top/bottom remain as they are            }
{                }


    function RowSelected (rowNumber: longint): boolean;
    {              }
{        returns true if at least a cell in the given row is selected,            }
{        false otherwise, or if the given row is outside the list.            }
{                }

    function CellSelected (row, column: longint): Boolean;
    {              }
{        returns true if the given cell is selected            }
{        run-time error if row/column is outside the list            }
{                }


    procedure SetCell (row, column: longint; s: Str255);
    {              }
{        sets the given cell cell to the string s            }
{                }


    procedure GetCell (var s: Str255; row, column: longint);
    {              }
{        returns the given cell cell in the string s            }
{                }


    procedure GetDefaultData (xColH, yColH, xErrColH, yErrColH: ExtendedArrayHandlePtr; indecesH: LongArrayHandlePtr; var arraySize: longint; selectedRowsOnly: Boolean; info: DataInfoPtr);

{        This routine provides you with a copy of the default x-y data in the            }
{        current Data window.            }
{        It allocates memory for the x,y arrays, for the x,y-Error arrays, and            }
{        for the array that gives the corresponding row numbers in the data window.            }
{        Then it fills them up with the data. It copies only the data where             }
{        both the x and the y cell contain valid numbers.            }
{        Pass nil for one of these array if you are not interested in it.            }

{        IndecesH contains, for each x-y data in the data-arrays, the row number in            }
{        the current data list where that data is found.            }

{        when selectedRowsOnly is true, only data in selected rows is used to fill up            }
{        the arrays.            }
{                    }
{        The arrays returned by GetDefaultData contain valid data starting from             }
{        the element with index 1. The value of the element with index 0 is undefined.            }
{        The last element has index "arraySize".            }
{        arraySize is set to zero in case of out-of-memory situations or other problems.            }
{                    }
{        Provide a pointer to a data struct of type DataInfo as the last paraemter if            }
{        you are interested in extra information on the data set.            }
{        The elements of the DataInfo struct are set by GetDefaultData, and they tell            }
{        you the boundaries of the x- and y- data, if the data is ordered with            }
{        x-values growing with the index in the arrays, if any cells in the columns            }
{        dedicated to the errors of the data points where found empty.            }
{        See the declaration of the DataInfo structure, above.            }
{                    }
{                }





{******************************************************************************            }
{****************************** miscellaneous ********************************            }


    procedure SetWaitTitle (s: Str255);

{        writes the string s in the window put up by profit while running programs            }
{        This string serves as a title.            }
{                }


    procedure SetWaitText (s1, s2, s3, s4, s5, s6: Str255);

{        writes the strings s1-s6 in the window put up by profit while running programs            }
{        in a two columns by three row arrangement:            }
{        s1        s2            }
{        s3        s4            }
{        s5        s6            }
{        Use an empty string if you don't want to change it.            }
{                }


    function MarkedX (i: integer): extended;
    function MarkedY (i: integer): extended;

{    return the x and y coordinate of a marker in the preview window.            }
{    i is the index of the marker.            }
{    i = 0 for the reference marker.            }
{                }

    procedure MarkedCoord (i: integer; var x, y: extended);

{    returns the x and y coordinates of a marker in the preview window.            }
{    i is the index of the marker.            }
{    i = 0 for the reference marker.            }
{                }


    procedure DoMenu (s: Str255);

{        executes a menu command, with the same effect as if the command            }
{        is chosen by hand.            }
{        s is of the type 'MenuTitle:MenuItem' or 'MenuTitle:SubmenuTitle:MenuItem'            }
{        Causes a run-time error if such a menu item does not exist.            }
{        add "$OK" at the end of the string if you want to bypass dialog boxes            }
{        and simulate a click on ok.            }
{                }



    function TestStop: boolean;
{ returns true if a user presses the command key and '.' , or if proFit likes to stop the execution of the function or program             }

    procedure StopExecution;
{ tells proFit to stop the execution after having completed             }
{ the actual function call (First, Run,  etc .)             }


    function GetAndSetStatus(newStatus:integer; var s: Str255):integer;
{ Returns the present execution status, then sets it to newStatus }
{ The status can be: }
{    0: if normal operation }
{    1: if the user interrupted operation }
{    2: if a warning has been posted }
{    3: if a run-time error has been posted }
{ Set newStatus to -1 if you don't want to change the current status }
{ If you set a status 2 or 3, pass a suitable error or warning message }
{ in s It will be shown once your module is finshed. }
{ On return, s holds the current message (if status was 2 or 3) }
{ Note, that calling StopExecution is equivalent to setting error status }
{ to 1 and TestStop returns true if error status is 1 or 3 }




{******************************************************************************            }
{***************************** advanced routines ******************************            }




{    The following routines are provided for the experienced programmer.            }
{    They allow for more power and flexibility when writing powerful            }
{    external modules.            }



    procedure HandleEvent (var theEvent: EventRecord);

{        Passes theEvent to pro Fit for handling it. Use this call to            }
{        handle update events when creating your own window.            }
{                }

    function CancelEvent (var theEvent: EventRecord):Boolean;

{        returns true if theEvent is a key-down event for the escape key or cmd-'.' }
{                }

    procedure DeactivateProFitWindows;

{        Deactivates all of pro Fit's windows and disables all menus.            }
{        Call this routine before showing a window or creating a dialog.            }
{        Each call to DectivateProFitWindows must be matched with a call to            }
{        ActivateProFitWindows            }
{                }

    procedure ActivateProFitWindows;

{        Activates pro Fit's frontmost window and enables the menus.            }
{        Call this routine after closing a window or a dialog.            }
{        Each call to ActivateProFitWindows must be preceded by a call to            }
{        DectivateProFitWindows            }
{                }

    function GetModuleFile: FSSpecPtr;

{        Returns a pointer to the FSSpec record of this file of this module.            }
{                }



{ advanced data access routines             }

{ The following definitions are used for accessing 8 byte floating point values on }
{ compilers that do not recognize this data type }
{ We define the following data types and symbols: }
{    double_8:    an 8 byte floating point value type }
{    COMPILER_KNOWS_DOUBLE_8:    this symbol is true if the compiler knows how to convert between }
{                                double_8 and extended. It is false if you must use the }
{                                functions Dbl8ToExt and ExtToDbl8 for this conversion }
{    EXT_SIZE:                    this symbol is 8, 10 or 12, depending on the size of the type extended }

    type

{$IFC GENERATINGPOWERPC }
    { For PowerPC compilers, double and extended are 8 bytes, so there's no conversion necessary }
    {$SETC COMPILER_KNOWS_DOUBLE_8 := true}
    {$SETC EXT_SIZE := 8}
        double_8 = double;                { a 8 byte floating point number }
{$ELSEC}
    {$IFC NOT UNDEFINED THINK_PASCAL }
        { Think Pascal can convert between double_8 and extended }
        {$SETC COMPILER_KNOWS_DOUBLE_8 := true}
        {$IFC OPTION(MC68881)}
            {$SETC EXT_SIZE := 12}
        {$ELSEC}
            {$SETC EXT_SIZE := 10}
        {$ENDC}
        double_8 = double;                { a 8 byte floating point number }
    {$ELSEC}
        { Metrowerks pascal and other pascal compilers cannot use 8 byte doubles while }
        { extended is 10 or 12 bytes }
        {$SETC COMPILER_KNOWS_DOUBLE_8 := false}
        {$IFC OPTION(MC68881)}
            {$SETC EXT_SIZE := 12}
        {$ELSEC}
            {$SETC EXT_SIZE := 10}
        {$ENDC}
        double_8 = array[0..1] of longint;    { MW Pascal does not support 8 byte floating point numbers }
                                            { We therefore define this record and the following routines }
                                            { for accessing this type }
    {$ENDC}
{$ENDC}


        FloatColumnArray = array[0..0] of real;        { a variable size array of 4 byte floating point numbers }
        DoubleColumnArray = array[0..0] of double_8;    { a variable size array of 8 byte floating point numbers }
                                        { GetColHandle/SetColHandle: Index [0] is reserved. First valid index is [1] }

        FloatColumnPtr = ^FloatColumnArray;
        FloatColumnHandle = ^FloatColumnPtr;        { column handle for columns of type floatColumn }

        DoubleColumnPtr = ^DoubleColumnArray;
        DoubleColumnHandle = ^DoubleColumnPtr;        { column handle for columns of type doubleColumn }

        TextColumnPtr = ^StringData;
        TextColumnHandle = ^TextColumnPtr;            { column handle for columns of type textColumn }


    procedure GetColHandle (col: longint; var colH: Handle; var length: longint; var colType: longint; forWriting: Boolean);

{        Returns a handle (colH) to the data of the given column. You can read and/or            }
{        modify the data in the handle. This is much faster than accessing a column's            }
{        data through GetData/SetData and GetCell/SetCell.              }
{        colH:        The handle to the column's data. Can be nil if the corresponding column            }
{                    is empty.            }
{        length:     the number of rows held by this column, presently always equal to the number            }
{                    of rows of the data window            }
{        forWriting: set to true if you intend to change the contents of the column,            }
{                    set to false otherwise.            }
{        colType:    the type of the column (textColumn, floatColumn, extendedColumn)            }
{        If you change the data in the returned handle, you must subsequently call            }
{        SetColHandle.            }
{        Do never call DisposeHandle(colH) — colH is allocated and deallocated by pro Fit.            }

{        if colType = floatColumn, colH is a handle of type FloatColumnHandle            }
{              (handle to an array of 4-byte floating point values)            }
{        if colType = extendedColumn, colH is of type extendedColumnHandle            }
{            (handle to an array of 8-byte floating point values)            }
{        if colType = textColumn, colH is of type TextColumnHandle.            }
{               (handle to a record of type StringData)            }

{        Note: For columns of type floatColumn and extendedColumn, the first entry of the            }
{        array is reserved. The value of the first cell is found in the array element            }
{        having index 1.            }

{        Note2: if colType = extendedColumn, the values are stored as 8 byte doubles (double_8) }
{        Some compilers cannot convert between double_8 and extended and cannot run calculations }
{        with double 8. For such comilers, the symbol COMPILER_KNOWS_DOUBLE_8 defined above is false }
{        To access double_8 values from a compiler that does not support this type, use the }
{        routines Dbl8ToExt and ExtToDbl8 defined below }

{        Warning: This routine should by used by experienced programmers only.            }
{        Warning: Accessing text columns in this way is _not_ recommended. The             }
{                 definition of the data structure may change in the future.            }

{        While you are working on the data in colH, you should not call any other            }
{        routines accessing the data window except GetColumnHandle and SetColumnHandle.            }
{        When you modify the data in colH, you should avoid calling any pro Fit routines            }
{        until you have called SetColHandle — if you want to call other pro Fit routines,            }
{        first make a copy of the data by using HandToHand; once you have made all            }
{        modifications to the data, call SetColHandle.            }
{                }

    procedure SetColHandle (col: longint; colH: Handle);

{        Sets a given column to the data in colH.             }
{        The organization of the data in colH depends on the data type of the column:            }
{         if floatColumn, colH is a handle of type FloatColumnHandle            }
{              (handle to an array of 4-byte floating point values)            }
{        if extendedColumn, colH is of type extendedColumnHandle            }
{            (handle to an array of 8-byte floating point values)            }
{        if textColumn, colH is of type TextColumnHandle.            }
{            (handle to a record of type StringData)            }
{        (To get a column's type, call GetColType)            }

{        Once you call SetColHandle, the handle becomes property of pro Fit — do            }
{        not dispose it.            }
{        colH can either be:            }
{          - a handle that you allocated yourself. In this case, the Handle's size must be:            }
{            4*(nrRows+1) for columns of type floatColumn            }
{            8*(nrRows+1) for columns of type extendedColumn            }
{            14 + size of all strings for columns of type textColumn            }
{          - a handle that you obtained from GetColHandle            }
{         - nil if you want to clear the given column            }

{        Note: if colType = extendedColumn, the values are stored as 8 byte doubles (double_8) }
{        Some compilers cannot convert between double_8 and extended and cannot run calculations }
{        with double 8. For such comilers, the symbol COMPILER_KNOWS_DOUBLE_8 defined above is false }
{        To access double_8 values from a compiler that does not support this type, use the }
{        routines Dbl8ToExt and ExtToDbl8 defined below }

{        Warning: This routine should by used by experienced programmers only.            }
{        Warning: Accessing text columns in this way is _not_ recommended. The             }
{                 definition of the data structure may change in the future.            }
{                }

    function Dbl8ToExt (x: double_8): extended;
    { converts the double_8 value x into an extended (10 byte) value }
    { This function is only required for comilers that do not support the double_8 data type }

    function ExtToDbl8 (x: extended): double_8;
    { converts the double_8 value x into an extended (10 byte) value }
    { This function is only required for comilers that do not support the double_8 data type }



{$IFC GENERATING68K}
    procedure runtimeProc (pb, p: ptr);
{ This routine is a gateaway for calling the set of proFit's procedures and functions that use            }
{ the parameters contained in the record runTimeParamRec. You do not need to work directly            }
{ with runTimeParamRec. Just use the procedures and functions defined below. These procedure            }
{ correctly set the parameters contained in runTimeParamRec and call the runtimeProc to produce            }
{ the expected results.              }
    inline
        $205F, $4E90;

    function MyMemory (i: integer): integer;
{ The code of this routine will be replaced by data - this routine is never called             }
{$ENDC}

    function GetPb: ExtModulesParamBlockPtr;
{ returns the current parameter block. Only advanced                             }
{ programmers may need this function.                                         }
{ WARNING: the definition of ExtModulesParamBlock may change in future versions                             }
{ of pro Fit. Using it from within your function may cause compatibility problems                             }
{ with those future versions.                            }

    procedure StartUp (pb: ExtModulesParamBlockPtr);
{ should be called by main() at beginning             }



implementation

{ This implementation part contains code that takes care of the communication between                }
{ an external module and proFit.                                                }

{ Everything that you need to know to produce an External Module for proFit                }
{ can be found in the interface part.                                                }
{ Just "use" this file in the "uses" statment at the beginning of the file containing your                }
{ code, as it is done in FunctionTemplate.p and ProgramTemplate.p.                }
{ It is easier and faster if you use one of these files to create a new external module.                }

{ You do not need to understand what is going on in the implementation part of this file                 }
{ unless you need to do very advanced and exotic things.                }

{$IFC NOT GENERATING68K}
        { if generating PPC code             }
    var
        staticPb: ExtModulesParamBlockPtr;


    procedure StartUp (pb: ExtModulesParamBlockPtr);
    begin
        staticPb := pb;
    end;

    function GetPb: ExtModulesParamBlockPtr;
    begin
        GetPb := staticPb;
    end;

    function CallUniversalProc (theProcPtr: UniversalProcPtr; procInfo: ProcInfoType; pb: ptr): LONGINT;
        C;
    external;

    procedure CallRuntimeProc (pb: ptr);
        var
            upp: UniversalProcPtr;
            dummy: longint;
    begin
        upp := NewRoutineDescriptor(staticPb^.RunTimeProcPtr, $000000C1, kPowerPCISA);
        if (upp <> nil) then
            begin
                dummy := CallUniversalProc(upp, $000000C1, pb);
                DisposeRoutineDescriptor(upp);
            end;
    end; { CallRuntimeProc             }

{$ELSEC}
    { if generating 68k code             }

    function MyMemory (i: integer): integer;
    begin
        MyMemory := i - 1;        { just generate some code             }
    end;


    procedure StartUp (pb: ExtModulesParamBlockPtr);
        var
            p: ExtModulesParamBlockH;
    begin
        p := ExtModulesParamBlockH(@MyMemory);        { this is a dirty trick for storing pb in static memory             }
        p^ := pb;
    end;

    function GetPb: ExtModulesParamBlockPtr;
        var
            p: ExtModulesParamBlockH;
    begin
        p := ExtModulesParamBlockH(@MyMemory);        { this is a dirty trick for storing pb in static memory             }
        GetPb := p^;
    end;

    procedure CallRuntimeProc (pb: ptr);
        var
            p: ExtModulesParamBlockH;
    begin
        p := ExtModulesParamBlockH(@MyMemory);        { this is a dirty trick for storing pb in static memory             }
        runtimeProc(pb, p^^.RunTimeProcPtr);
    end; { CallRuntimeProc             }
{$ENDC}
    type

{ the following record is used as a parameter block for all the routines provided by proFit }
{ This file defines a set of procedures that provide calls to the functions and            }
{ procedures that use the record  runTimeParamRec  as a parameter.   These procedures and functions    }
{ correctly set the parameters contained in runTimeParamRec and call  runtimeProc to produce        }
{ the expected results. The declaration of these procedures is found above, in the interfaceend;}
{ part. The implementation is found below, at the end of this file.                    }


{$ALIGN MAC68K}
        runTimeParamRec = record
                result: osErr;            { noErr or error code }
                what: integer;        { the operation }
{    "what" can currently assume the following values:                                }
{    1:    Obsolete. Used for "newCurve" in earlier versions }
{    2:    moveto }
{    3:     lineto }
{    4:    GetGraphCoordinates }
{    5:    CreateNewGraf  }
{    6:    Obsolete. Used for "NewDataSet" in earlier versions  }
{    7:    Obsolete. Used for an earlier version of AddDataPoint  }
{    11: random }
{    12:    TestStopend;}
{    13:    writeend;}
{    14:    writelnend;}
{    15:    writeExtendedend;}
{    16:    alertend;}
{    17:    inputend;}
{    18:    askend;}
{    19:    SetColumnNameend;}
{    20-23:xColumn, yColumn, xErrColumn, yErrColumnend;}
{    24:    GetSelectionend;}
{    25:    GetDataend;}
{    26:    SetDataend;}
{    27:    ClearDataend;}
{    28:    TestDataend;}
{    29:    NumberInvalidend;}
{    30:    SetParamLimitsend;}
{    31:    SetParamDefaultValueend;}
{    32:    SetParamNamesend;}
{    33:    SetParamDefaultsend;}
{    34:    NrRowsend;}
{    35:    NrColsend;}

{    40:    StopExecutionend;}

{     41:    Erf                                                    (v. 5 and later)                        }
{     42:    Erfc                                                (v. 5 and later)}
{     43:    function MarkX(i:integer):extended;                    (v. 5 and later)}
{     44:    function MarkY(i:integer):extended;                    (v. 5 and later)}
{     45:    procedure MarkCoords(i:integer; var x,y:extended);    (v. 5 and later)    }


{    100:    CallFunctionend;}
{    101:    GetFunctionParamend;}
{    102:    SetFunctionParamend;}
{    103:    CallProgramend;}
{    104:    GetFunctionParamModeend;}
{    105:    GetFunctionParamNumend;}
{    110:    CalculateIntegralend;}
{    111-114:maxima, minima, roots,derivative }
{    120-124:chiSquared,numFitParams,fittedParams, covar,paramSD }

{    All following routines are available starting from pro Fit version 5 and later.}
{     }
{    125-126:SetErrorAnalysisDefaults, ConfidenceInterval                }
{    130-133:calcStat, getBasics, getSkew, getMedian            }

{    135:        DoMenu}

{    150-154:    FrontWindow, NewWindow, SetCurrentWindow, GetCurrentWindow, CloseWindow}
{    155-159:    FrontmostWindow, SaveWindow, SaveWindowAs, GetWindowID, GetWindowType}
{    160-163:    GetNextWindow, OpenFile, OpenData, OpenText}
{    164-165:    SaveDataAsText, SaveDrawingAs}
{    166      : SetWindowTitle}
{    167-168: PlaceWindow, BringWindowToFront}
{    169      : Compile}

{    170-172:    SetDataWindowSize, GetColType, SetColType}
{    173-177: SelectCells, SelectRows, RowSelected, CellSelected, SetCell}
{    173-177: SelectCells, SelectRows, RowSelected, CellSelected, SetCell}
{    178-182: GetCell, GetColumnName, SetDefaultColumns, GetColHandle, SetColHandle}
{    186-187: SetBoxTitle, SetWindowInfo}
{     }
{    189:     SetTextFileFormat}
{    190-192: CreateTextFile, CloseTextFile, WriteToTextFile}
{    193-196: HandleEvent, DeactivateWindows, ActivateWindows, CancelEvent}
{    197-198: NumberToStr255, Str255ToNumber, GetAndSetStatus}
{    197-198: NumberToStr255, Str255ToNumber}

{    200-207:    SetLineStyle,SetFillPattern,SetArrowStyle,SetTextStyle}
{                 SetDataPointStyle, SetBGDataPointStyle,SetLineColor,SetFillColor}
{    208-222: DrawRect,DrawEllipse,DrawLine,DrawTextLine,DrawNumber,DrawDataPoint,OpenPolygon,ClosePolygon,}
{                 CloseCurve, CloseDataSet,SetNewGraphRect,GroupBegin,Move,Line}
{    223:        GetLastClickedCoordinates}
{    224,225:    OpenCurve, OpenDataSet}
{    226        DisableDrawingUpdates}
{    227-229:    SetCurrentGraph, GetNextGraph, GetCurrentGraph}
{    230-231:    GetGraphFrame, SetGraphFrame}
{    232-245:    GetCurrentAxis,SetCurrentAxis,DeleteAxis,MakeNewAxis,SetRange,MakeTicks}
{                 SetLabelsFormat,ClearTicks,ClearLabels,AddTick,SetLabel,SetLabelText}
{                 SetAxisPosition,SetAxisAttributes}
{    246:        SetGraphAttributes}
{    247:        DrawPICT}
{    248-249:    SetCurveFill, SetEBarStyle}
{    250        AddDataPoint            }

                case integer of
                    0: (
                            p: array[0..7] of Ptr;    { pointers to routine parameters used by version 5.0 and later }
                                                { The type of the parameters is specified in the implementation }
                                                { of the routines in proFit_interface2.p                        }
                    );
                    2, 3: (
                            y, x: extended;
                    );    { lineto, moveto }
                    4: (
                            ymax, ymin, xmax, xmin: ^extended;
                    );    { GetGraphCoordinates }
                    5: (
                            xmin5, xmax5, ymin5, ymax5: extended;
                            xScaling, yScaling: integer;
                    );    { createNewGraf }
                    11, 20, 21, 22, 23, 120: (
                            retval11: extended;
                    );    { random, xErrColumn,yColumn,xErrColumn,yErrColumn,ChiSquared }
                    12: (
                            retval12: boolean;
                    );    { executionstopped }
                    13, 14: (
                            theMessage: StringPtr;
                    );    { write/writeln }
                    15: (
                            extVal: extended;
                    );{ WriteNumber }
                    16: (
                            theMessage16: StringPtr;
                            retval16: boolean;
                    );    { alert }
                    17: (
                            r: ^InputRec;
                            nrargs: integer;
                            retval17: boolean;
                    );    { MyInput }
                    18: (
                            question: StringPtr;
                            answer: ^integer;
                            retval18: boolean;
                    );    { ask }
                    19: (
                            name: StringPtr;
                            column19: longint;
                    );    { SetColumnName }
                    24: (
                            selectionRect: Rect;
                    );    { GetSelection }
                    25, 26: (
                            column25, row25: longint;
                            cellValue: extended;
                    );    { GetData/SetData }
                    27: (
                            column27, row27: longint;
                    );    { ClearData }
                    28: (
                            column28, row28: longint;
                            retval28: boolean;
                    );    { TestData }
                    29: (
                            aNum: extended;
                            retval29: boolean;
                    );    { NumberInvalid }
                    30: (
                            ahigh, alow: extended;
                            paramIndex30: integer;
                    );    { SetParamLimits }
                    31: (
                            aval: extended;
                            paramIndex31: integer;
                    );    { SetParamDefaultValue }
                    32: (
                            aName32: StringPtr;
                            paramIndex32: integer;
                    );    { SetParamName }
                    33: (
                            ahigh33, alow33: extended;
                            aName33: StringPtr;
                            amode33: integer;
                            aval33: extended;
                            paramIndex33: integer;
                    );    { SetParamDefaults }
                    100: (
                            xval: extended;
                            funcName100: StringPtr;
                            retval100: extended;
                    );    { callfunction }
                    101, 104: (
                            paramIndex101: integer;
                            funcName101: StringPtr;
                            retval101: extended;
                    );    { getfunctionparam, getfunctionparammode }
                    102: (
                            pVal: extended;
                            paramIndex102: integer;
                            funcName102: StringPtr;
                    );    { setfunctionparamend;}
                    103: (
                            progName: StringPtr;
                    );    { callProgram }
                    105: (
                            funcName105: StringPtr;
                            retval105: extended;
                    );    { getfunctionparamnum }
                    110: (
                            numIterations: integer;
                            max, min: extended;
                            funcName110: StringPtr;
                            retval110: extended;
                    );    { DoIntegrate }
                    111, 112, 113, 114: (
                            max111, min111: extended;
                            funcName111: StringPtr;
                            retval111: extended;
                    );    { findMaximum, findMinimum, findRoot,derivative }
                    115: (
                            xCol, yCol, errCol: longint;
                            errVal: extended;
                            selectionOnly: longint;
                            funcName115: StringPtr;
                    );    { Fit }
                    121: (
                            numFitParams: integer;
                    );    { numFitParams }
                    122, 123: (
                            paramIndex122: integer;
                            retval122: extended;
                    );    { fittedParams, paramSD }
                    124: (
                            paramIndex1, paramIndex2: integer;
                            retval124: extended;
                    );    { CovarMatrix }


            end;

{$ALIGN RESET}


    procedure GrMoveto (x, y: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.x := x;
        pb.y := y;
        pb.what := 2;
        CallRuntimeProc(@pb);
    end;

    procedure GrLineto (x, y: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.x := x;
        pb.y := y;
        pb.what := 3;
        CallRuntimeProc(@pb);
    end;

    procedure GrMove (x, y: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 221;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
    end;

    procedure GrLine (x, y: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 222;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
    end;

    procedure GetGraphCoordinates (var xmin, xmax, ymin, ymax: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.xmin := @xmin;
        pb.xmax := @xmax;
        pb.ymin := @ymin;
        pb.ymax := @ymax;
        pb.what := 4;
        CallRuntimeProc(@pb);
    end;

    procedure CreateNewGraf (xmin, xmax, ymin, ymax: extended; xScaling, yScaling: integer);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 5;
        pb.xmin5 := xmin;
        pb.xmax5 := xmax;
        pb.ymin5 := ymin;
        pb.ymax5 := ymax;
        pb.xScaling := xScaling;
        pb.yScaling := yScaling;
        CallRunTimeProc(@pb);
    end;

    function pRandom: extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 11;
        CallRuntimeProc(@pb);
        pRandom := pb.retval11;
    end;

    function TestStop: boolean;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 12;
        CallRuntimeProc(@pb);
        TestStop := pb.retval12;
    end;

    procedure StopExecution;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 40;
        CallRuntimeProc(@pb);
    end;

    function GetAndSetStatus(newStatus:integer; var s: Str255):integer;
        var
            pb: runTimeParamRec;
            retval:integer;
    begin
        pb.what := 199;
        pb.p[0] := @s[0];
        pb.p[1] := @newStatus;
        pb.p[2] := @retval;
        CallRuntimeProc(@pb);
        GetAndSetStatus := retval;
    end;

    procedure WriteString (s: Str255);
        var
            pb: runTimeParamRec;
    begin
        pb.theMessage := @s;
        pb.what := 13;
        CallRuntimeProc(@pb);
    end;



    procedure WritelnString (s: Str255);
        var
            pb: runTimeParamRec;
    begin
        pb.theMessage := @s;
        pb.what := 14;
        CallRuntimeProc(@pb);
    end;

    procedure WriteText(length: longint; theText: Ptr);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 188;
        pb.p[1] := @length;
        pb.p[0] := theText;
        CallRunTimeProc(@pb);
    end;

    procedure WriteInt (i: longint);
        var
            s: str255;
    begin
        NumToString(i, s);
        WriteString(s);
    end;

    procedure WriteNumber (d: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 15;
        pb.extVal := d;
        CallRuntimeProc(@pb);
    end;

    procedure NumberToStr255(x: extended; var s: Str255; format, digits:integer);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 197;
        pb.p[0] := @digits;
        pb.p[1] := @format;
        pb.p[2] := @s[0];
        pb.p[3] := @x;
        CallRuntimeProc(@pb);
    end;

    function Str255ToNumber(s: Str255; var x: extended):integer;
        var
            pb: runTimeParamRec;
            retval: integer;
    begin
        pb.what := 198;
        pb.p[0] := @x;
        pb.p[1] := @s[0];
        pb.p[2] := @retval;
        CallRuntimeProc(@pb);
        Str255ToNumber := retval;
    end;

    function AlertBox (s: str255): boolean;
        var
            pb: runTimeParamRec;
    begin
        pb.theMessage := @s;
        pb.what := 16;
        CallRuntimeProc(@pb);
        AlertBox := pb.retval16;
    end;

    function InputBox (nrArgs: integer; var r: inputRec): boolean;
        var
            pb: runTimeParamRec;
    begin
        pb.nrArgs := nrArgs;
        pb.r := @r;
        pb.what := 17;
        CallRuntimeProc(@pb);
        InputBox := pb.retval17;
    end;




    function AskBox (var answer: integer; s: str255): boolean;
        var
            pb: runTimeParamRec;
    begin
        pb.question := @s;
        pb.what := 18;
        pb.answer := @answer;
        CallRuntimeProc(@pb);
        AskBox := pb.retval18;
    end;




    procedure SetColName (Column: longint; s: str255);
        var
            pb: runTimeParamRec;
    begin
        pb.column19 := Column;
        pb.name := @s;
        pb.what := 19;
        CallRuntimeProc(@pb);
    end;


    function xColumn: longint;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 20;
        CallRuntimeProc(@pb);
        xColumn := round(pb.retval11);
    end;

    function yColumn: longint;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 21;
        CallRuntimeProc(@pb);
        yColumn := round(pb.retval11);
    end;

    function xErrColumn: longint;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 22;
        CallRuntimeProc(@pb);
        xErrColumn := round(pb.retval11);
    end;

    function yErrColumn: longint;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 23;
        CallRuntimeProc(@pb);
        yErrColumn := round(pb.retval11);
    end;

    procedure SetDefaultCols (xColumn, yColumn, xErrColumn, yErrColumn: longint);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 180;
        pb.p[3] := @xColumn;
        pb.p[2] := @yColumn;
        pb.p[1] := @xErrColumn;
        pb.p[0] := @yErrColumn;
        CallRunTimeProc(@pb);
    end;

    function GetSelection: rect;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 24;
        CallRuntimeProc(@pb);
        GetSelection := pb.selectionRect;
    end;


    function NrRows: longint;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 34;
        CallRuntimeProc(@pb);
        NrRows := round(pb.retval11);
    end;

    function NrCols: longint;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 35;
        CallRuntimeProc(@pb);
        NrCols := round(pb.retval11);
    end;



    function GetData (Row, Column: longint): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.column25 := Column;
        pb.row25 := Row;
        pb.what := 25;
        CallRuntimeProc(@pb);
        GetData := pb.cellValue;
    end;

    procedure SetData (Row, Column: longint; ex: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.column25 := Column;
        pb.row25 := Row;
        pb.what := 26;
        pb.cellValue := ex;
        CallRuntimeProc(@pb);
    end;


    procedure ClearData (Row, Column: longint);
        var
            pb: runTimeParamRec;
    begin
        pb.column27 := Column;
        pb.row27 := Row;
        pb.what := 27;
        CallRuntimeProc(@pb);
    end;


    function TestData (Row, Column: longint): boolean;
        var
            pb: runTimeParamRec;
    begin
        pb.column28 := Column;
        pb.row28 := Row;
        pb.what := 28;
        CallRuntimeProc(@pb);
        TestData := pb.retval28;
    end;

    function NumberInvalid (aNum: extended): boolean;
        var
            pb: runTimeParamRec;
    begin
        pb.aNum := aNum;
        pb.what := 29;
        CallRuntimeProc(@pb);
        NumberInvalid := pb.retval29;
    end;

    procedure SetParamLimits (paramNum: integer; low, high: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 30;
        pb.alow := low;
        pb.ahigh := high;
        pb.paramIndex30 := paramNum;
        CallRuntimeProc(@pb);
    end;

    procedure SetParamDefaultValue (paramNum: integer; value: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 31;
        pb.aval := value;
        pb.paramIndex31 := paramNum;
        CallRuntimeProc(@pb);
    end;

    procedure SetParamName (paramNum: integer; s: Str255);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 32;
        pb.aname32 := @s;
        pb.paramIndex32 := paramNum;
        CallRuntimeProc(@pb);
    end;

    procedure SetParamDefaults (paramNum: integer; value: extended; mode: modeType; name: Str255; low, high: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 33;
        pb.alow33 := low;
        pb.ahigh33 := high;
        pb.aname33 := @name;
        pb.amode33 := integer(mode);
        pb.aval33 := value;
        pb.paramIndex33 := paramNum;
        CallRuntimeProc(@pb);
    end;

    function CallFunction (name: Str255; xvalue: extended): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 100;
        pb.funcName100 := @name;
        pb.xval := xvalue;
        CallRuntimeProc(@pb);
        CallFunction := pb.retval100;
    end;

    function GetNumFunctionParams (functionName: Str255): integer;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 105;
        pb.funcName105 := @functionName;
        CallRuntimeProc(@pb);
        GetNumFunctionParams := round(pb.retval105);
    end;

    function GetFunctionParamMode (functionName: Str255; paramIndex: integer): modeType;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 104;
        pb.funcName101 := @functionName;
        pb.paramIndex101 := paramIndex;
        CallRuntimeProc(@pb);
        GetFunctionParamMode := ModeType(round(pb.retval101));
    end;

    procedure GetFunctionParamName(functionName: Str255; paramIndex: integer; var paramName: Str255);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 106;
        pb.p[0] := @paramName;
        pb.p[1] := @paramIndex;
        pb.p[2] := @functionName;
        CallRuntimeProc(@pb);
    end;

    function GetFunctionParam (functionName: Str255; paramIndex: integer): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 101;
        pb.funcName101 := @functionName;
        pb.paramIndex101 := paramIndex;
        CallRuntimeProc(@pb);
        GetFunctionParam := pb.retval101;
    end;

    procedure SetFunctionParam (functionName: Str255; paramIndex: integer; value: extended);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 102;
        pb.funcName102 := @functionName;
        pb.paramIndex102 := paramIndex;
        pb.pVal := value;
        CallRuntimeProc(@pb);
    end;

    procedure CallProgram (name: Str255);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 103;
        pb.progName := @name;
        CallRuntimeProc(@pb);
    end;

    function Integral (functionName: Str255; xmin, xmax: extended; numIters: integer): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 110;
        pb.funcName110 := @functionName;
        pb.min := xmin;
        pb.max := xmax;
        pb.numIterations := numIters;
        CallRuntimeProc(@pb);
        Integral := pb.retval110;
    end;

    function Maximum (functionName: Str255; xmin, xmax: extended): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 111;
        pb.funcName111 := @functionName;
        pb.min111 := xmin;
        pb.max111 := xmax;
        CallRuntimeProc(@pb);
        Maximum := pb.retval111;
    end;

    function Minimum (functionName: Str255; xmin, xmax: extended): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 112;
        pb.funcName111 := @functionName;
        pb.min111 := xmin;
        pb.max111 := xmax;
        CallRuntimeProc(@pb);
        Minimum := pb.retval111;
    end;

    function Root (functionName: Str255; xmin, xmax: extended): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 113;
        pb.funcName111 := @functionName;
        pb.min111 := xmin;
        pb.max111 := xmax;
        CallRuntimeProc(@pb);
        Root := pb.retval111;
    end;

    function Derivative (functionName: Str255; x, scale: extended): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 114;
        pb.funcName111 := @functionName;
        pb.min111 := x;
        pb.max111 := scale;
        CallRuntimeProc(@pb);
        Derivative := pb.retval111;
    end;

    function Chisquared: extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 120;
        CallRuntimeProc(@pb);
        Chisquared := pb.retval11;
    end;

    procedure Fit (functionName: Str255; xCol, yCol, errCol: longint; errVal: extended; selectionOnly: Boolean);
        var
            pb: runTimeParamRec;
    begin
        pb.what := 115;
        pb.funcName115 := @functionName;
        pb.xCol := xCol;
        pb.yCol := yCol;
        pb.errCol := errCol;
        pb.errVal := errVal;
        if selectionOnly then
            pb.selectionOnly := 1
        else
            pb.selectionOnly := 0;
        CallRuntimeProc(@pb);
    end;

    function NumFitParams: integer;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 121;
        CallRuntimeProc(@pb);
        NumFitParams := pb.numFitParams;
    end;

    function FittedParams (paramNum: integer): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 122;
        pb.paramIndex122 := paramNum;
        CallRuntimeProc(@pb);
        FittedParams := pb.retval122;
    end;

    function ParamSD (paramNum: integer): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 123;
        pb.paramIndex122 := paramNum;
        CallRuntimeProc(@pb);
        ParamSD := pb.retval122;
    end;

    function CovarMatrix (paramNum1, paramNum2: integer): extended;
        var
            pb: runTimeParamRec;
    begin
        pb.what := 124;
        pb.paramIndex1 := paramNum1;
        pb.paramIndex2 := paramNum2;
        CallRuntimeProc(@pb);
        CovarMatrix := pb.retval124;
    end;


    function PErf (x: extended): extended;
        var
            retval: extended;
            pb: RunTimeParamRec;
    begin
        pb.what := 41;
        pb.p[0] := @x;
        pb.p[1] := @retVal;
        CallRunTimeProc(@pb);
        PErf := retVal;
    end;

    function Erf (x: extended): extended;
    begin
        Erf := PErf(x);
    end;

    function PErfc (x: extended): extended;
        var
            retval: extended;
            pb: RunTimeParamRec;
    begin
        pb.what := 42;
        pb.p[0] := @x;
        pb.p[1] := @retVal;
        CallRunTimeProc(@pb);
        PErfc := retVal;
    end;

    function Erfc (x: extended): extended;
    begin
        Erfc := PErfc(x);
    end;

    function MarkedX (i: integer): extended;
        var
            retval: extended;
            pb: RunTimeParamRec;
    begin
        pb.what := 43;
        pb.p[0] := @i;
        pb.p[1] := @retVal;
        CallRunTimeProc(@pb);
        MarkedX := retVal;
    end;

    function MarkedY (i: integer): extended;
        var
            retval: extended;
            pb: RunTimeParamRec;
    begin
        pb.what := 44;
        pb.p[0] := @i;
        pb.p[1] := @retVal;
        CallRunTimeProc(@pb);
        MarkedY := retVal;
    end;

    procedure MarkedCoord (i: integer; var x, y: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 45;
        pb.p[2] := @i;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
    end;

    procedure SetFitDefaults (algorithm: integer; yErrDistribution: integer; xErrDistribution: integer; xErrColumn: longint; xErrValue: extended; stopTime: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 116;
        pb.p[5] := @algorithm;
        pb.p[4] := @yErrDistribution;
        pb.p[3] := @xErrDistribution;
        pb.p[2] := @xErrColumn;
        pb.p[1] := @xErrValue;
        pb.p[0] := @stopTime;
        CallRunTimeProc(@pb);
    end;

    function Maximize (theFunction: Str255; precision: extended; varyX: Boolean; var x, y: extended): Boolean;
        var
            retVal: Boolean;
            pb: RunTimeParamRec;
    begin
        pb.what := 117;
        pb.p[5] := @retVal;
        pb.p[4] := @theFunction;
        pb.p[3] := @precision;
        pb.p[2] := @varyX;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
        Maximize := retVal;
    end;

    function Minimize (theFunction: Str255; precision: extended; varyX: Boolean; var x, y: extended): Boolean;
        var
            retval: Boolean;
            pb: RunTimeParamRec;
    begin
        pb.what := 118;
        pb.p[5] := @retVal;
        pb.p[4] := @theFunction;
        pb.p[3] := @precision;
        pb.p[2] := @varyX;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
        Minimize := retVal;
    end;

    procedure SetErrorAnalysis (confidence: extended; iterations: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 125;
        pb.p[1] := @confidence;
        pb.p[0] := @iterations;
        CallRunTimeProc(@pb);
    end;

    procedure ConfidenceInterval (i: integer; var min, max: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 126;
        pb.p[2] := @i;
        pb.p[1] := @min;
        pb.p[0] := @max;
        CallRunTimeProc(@pb);
    end;


    function CalcStat (column: longint; selRowsOnly: Boolean; withBasics: Boolean; withSkewAndCurt: Boolean; withMedian: Boolean): Boolean;
        var
            retval: boolean;
            pb: RunTimeParamRec;
    begin
        pb.what := 130;
        pb.p[5] := @retVal;
        pb.p[4] := @column;
        pb.p[3] := @selRowsOnly;
        pb.p[2] := @withBasics;
        pb.p[1] := @withSkewAndCurt;
        pb.p[0] := @withMedian;
        CallRunTimeProc(@pb);
        CalcStat := retVal;
    end;

    procedure GetBasics (var count: longint; var sum, mean, variance, stdDev, meanAbsDev: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 131;
        pb.p[5] := @count;
        pb.p[4] := @sum;
        pb.p[3] := @mean;
        pb.p[2] := @variance;
        pb.p[1] := @stdDev;
        pb.p[0] := @meanAbsDev;
        CallRunTimeProc(@pb);
    end;

    procedure GetSkewAndKurt (var count: longint; var mean, variance, skewness, kurtosis: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 132;
        pb.p[4] := @count;
        pb.p[3] := @mean;
        pb.p[2] := @variance;
        pb.p[1] := @skewness;
        pb.p[0] := @kurtosis;
        CallRunTimeProc(@pb);
    end;


    procedure GetMedian (var count: longint; var mean, median, minimum, maximum: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 133;
        pb.p[4] := @count;
        pb.p[3] := @mean;
        pb.p[2] := @median;
        pb.p[1] := @minimum;
        pb.p[0] := @maximum;
        CallRunTimeProc(@pb);
    end;


    procedure DoMenu (s: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 135;
        pb.p[0] := @s;
        CallRunTimeProc(@pb);
    end;


    function GetFrontWindow: longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 150;
        pb.p[0] := @retVal;
        CallRunTimeProc(@pb);
        GetFrontWindow := retVal;
    end;

    procedure DoNewWindow (windowType: OSType);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 151;
        pb.p[0] := @windowType;
        CallRunTimeProc(@pb);
    end;


    procedure SetCurrentWindow (windowID: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 152;
        pb.p[0] := @windowID;
        CallRunTimeProc(@pb);
    end;

    function GetCurrentWindow (windowType: OSType): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 153;
        pb.p[1] := @retVal;
        pb.p[0] := @windowType;
        CallRunTimeProc(@pb);
        GetCurrentWindow := retVal;
    end;

    procedure DoCloseWindow (windowID: longint; saveIt: Boolean);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 154;
        pb.p[1] := @windowID;
        pb.p[0] := @saveIt;
        CallRunTimeProc(@pb);
    end;

    function FrontmostWindow (windowType: OSType): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 155;
        pb.p[1] := @retVal;
        pb.p[0] := @windowType;
        CallRunTimeProc(@pb);
        FrontmostWindow := retVal;
    end;

    procedure SaveWindow (windowID: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 156;
        pb.p[0] := @windowID;
        CallRunTimeProc(@pb);
    end;

    procedure SaveWindowAs (windowID: longint; fileName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 157;
        pb.p[1] := @windowID;
        pb.p[0] := @fileName;
        CallRunTimeProc(@pb);
    end;

    function GetWindowID (windowName: Str255): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 158;
        pb.p[1] := @retVal;
        pb.p[0] := @windowName;
        CallRunTimeProc(@pb);
        GetWindowID := retVal;
    end;


    function GetWindowType (windowID: longint): OSType;
        var
            retval: OSType;
            pb: RunTimeParamRec;
    begin
        pb.what := 159;
        pb.p[1] := @retVal;
        pb.p[0] := @windowID;
        CallRunTimeProc(@pb);
        GetWindowType := retVal;
    end;

    function NextWindow (windowID: longint): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 160;
        pb.p[1] := @retVal;
        pb.p[0] := @windowID;
        CallRunTimeProc(@pb);
        NextWindow := retVal;
    end;

    procedure OpenFile (fileName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 161;
        pb.p[0] := @fileName;
        CallRunTimeProc(@pb);
    end;

    procedure OpenData (fileName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 162;
        pb.p[0] := @fileName;
        CallRunTimeProc(@pb);
    end;

    procedure OpenText (fileName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 163;
        pb.p[0] := @fileName;
        CallRunTimeProc(@pb);
    end;

    procedure SetTextFileFormat (colDelimiter, endOfLine: Str255; withColTitles, copyInfoText: Boolean; nrHeaderLines, inputORoutput: longint);
        var
            wT, cI: longint;
            pb: RunTimeParamRec;
    begin
        if withColTitles then
            wT := 1
        else
            wT := 0;
        if copyInfoText then
            cI := 1
        else
            cI := 0;
        pb.what := 189;
        pb.p[2] := @colDelimiter;
        pb.p[1] := @endOfLine;
        pb.p[0] := @wT;
        pb.p[0] := @cI;
        pb.p[0] := @nrHeaderLines;
        pb.p[0] := @inputORoutput;
        CallRunTimeProc(@pb);
    end;

    procedure SaveDataAsText (windowID: longint; fileName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 164;
        pb.p[1] := @windowID;
        pb.p[0] := @fileName;
        CallRunTimeProc(@pb);
    end;

    procedure SaveDrawingAs (windowID: longint; fileName: Str255; format: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 165;
        pb.p[2] := @windowID;
        pb.p[1] := @fileName;
        pb.p[0] := @format;
        CallRunTimeProc(@pb);
    end;

    procedure SetWindowTitle (windowID: longint; name: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 166;
        pb.p[1] := @windowID;
        pb.p[0] := @name;
        CallRunTimeProc(@pb);
    end;

    procedure GetWindowTitle (windowID: longint; var name: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 149;
        pb.p[1] := @windowID;
        pb.p[0] := @name;
        CallRunTimeProc(@pb);
    end;


    procedure PlaceWindow (windowID: longint; windowRect: Rect);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 167;
        pb.p[4] := @windowID;
        pb.p[3] := @windowRect.left;
        pb.p[2] := @windowRect.top;
        pb.p[1] := @windowRect.right;
        pb.p[0] := @windowRect.bottom;
        CallRunTimeProc(@pb);
    end;


    procedure BringWindowToFront (windowID: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 168;
        pb.p[0] := @windowID;
        CallRunTimeProc(@pb);
    end;

    procedure Compile (windowID: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 169;
        pb.p[0] := @windowID;
        CallRunTimeProc(@pb);
    end;

    procedure SetDataSize (numberOfRows, numberOfColumns: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 170;
        pb.p[1] := @numberOfRows;
        pb.p[0] := @numberOfColumns;
        CallRunTimeProc(@pb);
    end;

    function GetColType (columnNumber: longint): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 171;
        pb.p[1] := @retVal;
        pb.p[0] := @columnNumber;
        CallRunTimeProc(@pb);
        GetColType := retVal;
    end;

    procedure SetColType (columnNumber: longint; theType: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 172;
        pb.p[1] := @columnNumber;
        pb.p[0] := @theType;
        CallRunTimeProc(@pb);
    end;


    procedure SetColWidth (columnNumber: longint; width: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 184;
        pb.p[1] := @columnNumber;
        pb.p[0] := @width;
        CallRunTimeProc(@pb);
    end;

    function ColEmpty (columnNumber: longint): boolean;
        var
            retval: boolean;
            pb: RunTimeParamRec;
    begin
        pb.what := 185;
        pb.p[1] := @retVal;
        pb.p[0] := @columnNumber;
        CallRunTimeProc(@pb);
        ColEmpty := retVal;
    end;

    procedure SetBoxTitle(title: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 186;
        pb.p[0] := @title[0];
        CallRunTimeProc(@pb);
    end;

    procedure SetWindowInfo(windowID:longint; length: longint; info: Ptr);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 187;
        pb.p[2] := @windowID;
        pb.p[1] := @length;
        pb.p[0] := info;
        CallRunTimeProc(@pb);
    end;

    procedure SelectCells (left, top, right, bottom: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 173;
        pb.p[3] := @left;
        pb.p[2] := @top;
        pb.p[1] := @right;
        pb.p[0] := @bottom;
        CallRunTimeProc(@pb);
    end;


    procedure SelectRows (top, bottom: longint; doSelect: Boolean);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 174;
        pb.p[2] := @top;
        pb.p[1] := @bottom;
        pb.p[0] := @doSelect;
        CallRunTimeProc(@pb);
    end;


    function RowSelected (rowNumber: longint): boolean;
        var
            retval: boolean;
            pb: RunTimeParamRec;
    begin
        pb.what := 175;
        pb.p[1] := @retVal;
        pb.p[0] := @rowNumber;
        CallRunTimeProc(@pb);
        RowSelected := retVal;
    end;

    function CellSelected (row, column: longint): Boolean;
        var
            retval: boolean;
            pb: RunTimeParamRec;
    begin
        pb.what := 176;
        pb.p[2] := @retVal;
        pb.p[1] := @row;
        pb.p[0] := @column;
        CallRunTimeProc(@pb);
        CellSelected := retVal;
    end;


    procedure SetCell (row, column: longint; s: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 177;
        pb.p[2] := @row;
        pb.p[1] := @column;
        pb.p[0] := @s;
        CallRunTimeProc(@pb);
    end;

    procedure GetCell (var s: Str255; row, column: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 178;
        pb.p[2] := @row;
        pb.p[1] := @column;
        pb.p[0] := @s;
        CallRunTimeProc(@pb);
    end;

    procedure GetColName (var name: Str255; column: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 179;
        pb.p[0] := @name;
        pb.p[1] := @column;
        CallRunTimeProc(@pb);
    end;

    procedure GetColHandle (col: longint; var colH: Handle; var length: longint; var colType: longint; forWriting: Boolean);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 181;
        pb.p[0] := @col;
        pb.p[1] := @colH;
        pb.p[2] := @length;
        pb.p[3] := @colType;
        pb.p[4] := @forWriting;
        CallRunTimeProc(@pb);
    end;

    procedure SetColHandle (col: longint; colH: Handle);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 182;
        pb.p[0] := @col;
        pb.p[1] := @colH;
        CallRunTimeProc(@pb);
    end;

    procedure GetDefaultData (xColH, yColH, xErrColH, yErrColH: ExtendedArrayHandlePtr; indecesH: LongArrayHandlePtr; var arraySize: longint; selectedRowsOnly: Boolean; info: DataInfoPtr);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 183;
        pb.p[7] := Ptr(xColH);
        pb.p[6] := Ptr(yColH);
        pb.p[5] := Ptr(xErrColH);
        pb.p[4] := Ptr(yErrColH);
        pb.p[3] := Ptr(indecesH);
        pb.p[2] := @arraySize;
        pb.p[1] := @selectedRowsOnly;
        pb.p[0] := Ptr(info);
        CallRunTimeProc(@pb);
    end;

    procedure SetWaitTitle (s: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 46;
        pb.p[0] := @s;
        CallRunTimeProc(@pb);
    end;

    procedure SetWaitText (s1, s2, s3, s4, s5, s6: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 47;
        pb.p[5] := @s1;
        pb.p[4] := @s2;
        pb.p[3] := @s3;
        pb.p[2] := @s4;
        pb.p[1] := @s5;
        pb.p[0] := @s6;
        CallRunTimeProc(@pb);
    end;


    function CreateTextFile (fileName: Str255): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 190;
        pb.p[1] := @retVal;
        pb.p[0] := @fileName;
        CallRunTimeProc(@pb);
        CreateTextFile := retVal;
    end;

    procedure CloseTextFile (fileRefNumber: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 191;
        pb.p[0] := @fileRefNumber;
        CallRunTimeProc(@pb);
    end;

    procedure WriteToTextFile (fileRefNumber: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 192;
        pb.p[0] := @fileRefNumber;
        CallRunTimeProc(@pb);
    end;


    procedure HandleEvent (var theEvent: EventRecord);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 193;
        pb.p[0] := @theEvent;
        CallRunTimeProc(@pb);
    end;

    function CancelEvent (var theEvent: EventRecord):Boolean;
        var
            pb: RunTimeParamRec;
            retval: Boolean;
    begin
        pb.what := 196;
        pb.p[0] := @theEvent;
        pb.p[1] := @retval;
        CallRunTimeProc(@pb);
        CancelEvent := retval;
    end;

    procedure DeactivateProFitWindows;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 194;
        CallRunTimeProc(@pb);
    end;

    procedure ActivateProFitWindows;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 195;
        CallRunTimeProc(@pb);
    end;

    function GetModuleFile: FSSpecPtr;
        var
            modulesParams: ExtModulesParamBlockPtr;
    begin
        modulesParams := GetPb;
        GetModuleFile := @modulesParams^.moduleFile;
    end;


    procedure OpenCurve (curveName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 224;
        pb.p[0] := @curveName;
        CallRunTimeProc(@pb);
    end;

    procedure CloseCurve;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 216;
        CallRunTimeProc(@pb);
    end;

    procedure OpenDataSet (errors: integer; connected: Boolean; datasetName: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 225;
        pb.p[2] := @errors;
        pb.p[1] := @connected;
        pb.p[0] := @datasetName;
        CallRunTimeProc(@pb);
    end;

    procedure CloseDataSet;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 217;
        CallRunTimeProc(@pb);
    end;

    procedure SetCurveFill (whichAxis: integer; axisID: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 248;
        pb.p[1] := @whichAxis;
        pb.p[0] := @axisID;
        CallRunTimeProc(@pb);
    end;

    procedure SetEBarStyle (caplength, capThick, lineThick: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 249;
        pb.p[2] := @caplength;
        pb.p[1] := @capThick;
        pb.p[0] := @lineThick;
        CallRunTimeProc(@pb);
    end;

    procedure AddDataPoint (x, y, xErr, yErr, xErr1, yErr1: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 250;
        pb.p[5] := @x;
        pb.p[4] := @y;
        pb.p[3] := @xErr;
        pb.p[2] := @yErr;
        pb.p[1] := @xErr1;
        pb.p[0] := @yErr1;
        CallRunTimeProc(@pb);
    end;



    procedure SetLineStyle (thick: extended; dash: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 200;
        pb.p[1] := @thick;
        pb.p[0] := @dash;
        CallRunTimeProc(@pb);
    end;

    procedure SetFillPattern (pattern: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 201;
        pb.p[0] := @pattern;
        CallRunTimeProc(@pb);
    end;

    procedure SetArrowStyle (arrowLocation: integer; style: integer; size: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 202;
        pb.p[2] := @arrowLocation;
        pb.p[1] := @style;
        pb.p[0] := @size;
        CallRunTimeProc(@pb);
    end;

    procedure SetTextStyle (fontName: Str255; size: extended; style: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 203;
        pb.p[2] := @fontName;
        pb.p[1] := @size;
        pb.p[0] := @style;
        CallRunTimeProc(@pb);
    end;

    procedure SetNewGraphRect (left, top, right, bottom: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 218;
        pb.p[3] := @left;
        pb.p[2] := @top;
        pb.p[1] := @right;
        pb.p[0] := @bottom;
        CallRunTimeProc(@pb);
    end;

    procedure SetDataPointStyle (style: integer; size: extended; thickness: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 204;
        pb.p[2] := @style;
        pb.p[1] := @size;
        pb.p[0] := @thickness;
        CallRunTimeProc(@pb);
    end;

    procedure SetBGDataPointStyle (style: integer; size: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 205;
        pb.p[1] := @style;
        pb.p[0] := @size;
        CallRunTimeProc(@pb);
    end;

    procedure SetLineColor (red, green, blue: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 206;
        pb.p[2] := @red;
        pb.p[1] := @green;
        pb.p[0] := @blue;
        CallRunTimeProc(@pb);
    end;

    procedure SetFillColor (red, green, blue: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 207;
        pb.p[2] := @red;
        pb.p[1] := @green;
        pb.p[0] := @blue;
        CallRunTimeProc(@pb);
    end;

    procedure DrawRect (left, top, right, bottom: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 208;
        pb.p[3] := @left;
        pb.p[2] := @top;
        pb.p[1] := @right;
        pb.p[0] := @bottom;
        CallRunTimeProc(@pb);
    end;

    procedure DrawEllipse (left, top, right, bottom: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 209;
        pb.p[3] := @left;
        pb.p[2] := @top;
        pb.p[1] := @right;
        pb.p[0] := @bottom;
        CallRunTimeProc(@pb);
    end;

    procedure DrawLine (start_h, start_v, end_h, end_v: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 210;
        pb.p[3] := @start_h;
        pb.p[2] := @start_v;
        pb.p[1] := @end_h;
        pb.p[0] := @end_v;
        CallRunTimeProc(@pb);
    end;

    procedure DrawTextLine (theString: Str255; theAngle: extended; docenter: Boolean);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 211;
        pb.p[2] := @theString;
        pb.p[1] := @theAngle;
        pb.p[0] := @docenter;
        CallRunTimeProc(@pb);
    end;


    procedure DrawNumber (theNum: extended; decs: integer; theAngle: extended; docenter: Boolean);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 212;
        pb.p[3] := @theNum;
        pb.p[2] := @decs;
        pb.p[1] := @theAngle;
        pb.p[0] := @docenter;
        CallRunTimeProc(@pb);
    end;

    procedure DrawDataPoint (x, y: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 213;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
    end;

    procedure DrawPICT (left, top, right, bottom: extended; thePict: PicHandle);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 247;
        pb.p[4] := @left;
        pb.p[3] := @top;
        pb.p[2] := @right;
        pb.p[1] := @bottom;
        pb.p[0] := Ptr(thePict);
        CallRunTimeProc(@pb);
    end;

    procedure GetLastClickedCoordinates (var x, y: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 223;
        pb.p[1] := @x;
        pb.p[0] := @y;
        CallRunTimeProc(@pb);
    end;

    procedure DisableDrawingUpdates;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 226;
        CallRunTimeProc(@pb);
    end;

    procedure OpenPolygon (smoothing: integer; kind: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 214;
        pb.p[1] := @smoothing;
        pb.p[0] := @kind;
        CallRunTimeProc(@pb);
    end;

    procedure ClosePolygon;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 215;
        CallRunTimeProc(@pb);
    end;


    procedure GroupBegin;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 219;
        CallRunTimeProc(@pb);
    end;

    procedure GroupEnd;
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 220;
        CallRunTimeProc(@pb);
    end;


    procedure SetCurrentGraph (graphID: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 227;
        pb.p[0] := @graphID;
        CallRunTimeProc(@pb);
    end;

    function GetCurrentGraph: longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 229;
        pb.p[0] := @retval;
        CallRunTimeProc(@pb);
        GetCurrentGraph := retval;
    end;

    function GetNextGraph (graphID: longint): longint;
        var
            retval: longint;
            pb: RunTimeParamRec;
    begin
        pb.what := 228;
        pb.p[1] := @retval;
        pb.p[0] := @graphID;
        CallRunTimeProc(@pb);
        GetNextGraph := retval;
    end;

    procedure GetGraphFrame (var left, top, right, bottom: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 230;
        pb.p[3] := @left;
        pb.p[2] := @top;
        pb.p[1] := @right;
        pb.p[0] := @bottom;
        CallRunTimeProc(@pb);
    end;

    procedure SetGraphFrame (left, top, right, bottom: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 231;
        pb.p[3] := @left;
        pb.p[2] := @top;
        pb.p[1] := @right;
        pb.p[0] := @bottom;
        CallRunTimeProc(@pb);
    end;

    function GetCurrentAxis (whichAxis: integer): integer;
        var
            retval: integer;
            pb: RunTimeParamRec;
    begin
        pb.what := 232;
        pb.p[1] := @retval;
        pb.p[0] := @whichAxis;
        CallRunTimeProc(@pb);
        GetCurrentAxis := retval;
    end;

    procedure SetCurrentAxis (whichAxis: integer; axisID: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 233;
        pb.p[1] := @whichAxis;
        pb.p[0] := @axisID;
        CallRunTimeProc(@pb);
    end;

    procedure DeleteAxis (whichAxis: integer; axisID: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 234;
        pb.p[1] := @whichAxis;
        pb.p[0] := @axisID;
        CallRunTimeProc(@pb);
    end;

    procedure MakeNewAxis (whichAxis: integer; min, max: extended; scaling: integer; position: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 235;
        pb.p[4] := @whichAxis;
        pb.p[3] := @min;
        pb.p[2] := @max;
        pb.p[1] := @scaling;
        pb.p[0] := @position;
        CallRunTimeProc(@pb);
    end;

    procedure SetRange (whichAxis: integer; min, max: extended; scaling: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 236;
        pb.p[3] := @whichAxis;
        pb.p[2] := @min;
        pb.p[1] := @max;
        pb.p[0] := @scaling;
        CallRunTimeProc(@pb);
    end;

    procedure MakeTicks (whichAxis: integer; firstMaj, distance: extended; nrMinTicks: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 237;
        pb.p[3] := @whichAxis;
        pb.p[2] := @firstMaj;
        pb.p[1] := @distance;
        pb.p[0] := @nrMinTicks;
        CallRunTimeProc(@pb);
    end;

    procedure SetLabelsFormat (whichAxis: integer; format: integer; decimals: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 238;
        pb.p[2] := @whichAxis;
        pb.p[1] := @format;
        pb.p[0] := @decimals;
        CallRunTimeProc(@pb);
    end;

    procedure ClearLabels (whichAxis: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 240;
        pb.p[0] := @whichAxis;
        CallRunTimeProc(@pb);
    end;

    procedure ClearTicks (whichAxis: integer);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 239;
        pb.p[0] := @whichAxis;
        CallRunTimeProc(@pb);
    end;

    function AddTick (whichAxis: integer; tickPos: extended; isMajor: Boolean): integer;
        var
            retval: integer;
            pb: RunTimeParamRec;
    begin
        pb.what := 241;
        pb.p[3] := @retval;
        pb.p[2] := @whichAxis;
        pb.p[1] := @tickPos;
        pb.p[0] := @isMajor;
        CallRunTimeProc(@pb);
        AddTick := retval;
    end;

    procedure SetLabel (whichAxis: integer; tickNum: integer; labelNumber: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 242;
        pb.p[2] := @whichAxis;
        pb.p[1] := @tickNum;
        pb.p[0] := @labelNumber;
        CallRunTimeProc(@pb);
    end;

    procedure SetLabelText (whichAxis: integer; tickNum: integer; labelText: Str255);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 243;
        pb.p[2] := @whichAxis;
        pb.p[1] := @tickNum;
        pb.p[0] := @labelText;
        CallRunTimeProc(@pb);
    end;

    procedure SetAxisPosition (whichAxis: integer; position: extended);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 244;
        pb.p[1] := @whichAxis;
        pb.p[0] := @position;
        CallRunTimeProc(@pb);
    end;

    procedure SetAxisAttributes (whichAxis: integer; flags: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 245;
        pb.p[1] := @whichAxis;
        pb.p[0] := @flags;
        CallRunTimeProc(@pb);
    end;

    procedure SetGraphAttributes (flags: longint);
        var
            pb: RunTimeParamRec;
    begin
        pb.what := 246;
        pb.p[0] := @flags;
        CallRunTimeProc(@pb);
    end;


{ The following routines are provided for converting 8 byte floating point values into extended values }
{ They are only required for compilers that do not support intermixing of 8 byte and 10/12 byte }
{ doubles, such as MW Pascal for 68k. The routines are not needed on a PowerMac (where }
{ extended variables are always 8 bytes) or on the Think Pascal compiler (which automatically }
{ converts between double_8 and extended. For compatibility purposes, the following routines }
{ are, however, provided for all compilers }



    function Dbl8ToExt (x: double_8): extended;
    { converts the double_8 value x into an extended (10 byte) value }

{$IFC COMPILER_KNOWS_DOUBLE_8}
    begin                { if the compiler automatically converts between double_8 and extended }
        Dbl8ToExt := x;    { then there's nothing to do for us }
    end;
{$ELSEC}


    {$IFC EXT_SIZE=12}
    { if extended is 12 bytes }
    procedure Convert_8_12 (d8: double_8; var x: extended);
    inline
        $206F, $0004,        { MOVEA.L   $0004(A7),A0 }
        $F210, $5400,        { FMOVE.D   (A0),FP0 }
        $2057,                { MOVEA.L   (A7),A0 }
        $F210, $6800,        { FMOVE.X   FP0,(A0) }
        $4FEF, $0008;        { LEA       $0008(A7),A7 }
    var
        result: extended;
begin
    Convert_8_12(x, result);
    Dbl8ToExt := result;
end;
    {$ELSEC}
    { if extended is 10 bytes }

    procedure Convert_8_10 (d8: double_8; var x: extended);
    inline
        $3F3C, $080E,    { MOVE.W    #$08OE,-(A7) }
        $A9EB;            { _FP68K, call SANE for the conversion }
    var
        result: extended;
begin
    Convert_8_10(x, result);
    Dbl8ToExt := result;
end;
    {$ENDC}
{$ENDC}


function ExtToDbl8 (x: extended): double_8;
    { converts the double_8 value x into an extended (10 byte) value }

{$IFC COMPILER_KNOWS_DOUBLE_8}
begin                { if the compiler automatically converts between double_8 and extended }
    ExtToDbl8 := x;    { then there's nothing to do for us }
end;
{$ELSEC}


    {$IFC EXT_SIZE=12}
    { if extended is 12 bytes }

procedure Convert_12_8 (x: extended; var d8: double_8);
    { converts the extended (12 byte) value x into a double_8 (8 byte) value }
inline
        $206F, $0004,        { MOVEA.L   $0004(A7),A0 }
        $F210, $4800,        { FMOVE.X   (A0),FP0 }
        $2057,                { MOVEA.L   (A7),A0 }
        $F210, $7400,        { FMOVE.D   FP0,(A0) }
        $4FEF, $0008;        { LEA       $0008(A7),A7 }
var
    result: double_8;
begin
    Convert_12_8(x, result);
    ExtToDbl8 := result;
end;

    {$ELSEC}
    { if extended is 10 bytes }

procedure Convert_10_8 (x: extended; var d8: double_8);
    { converts the extended (10 byte) value x into a double_8 (8 byte) value }
inline
    $3F3C, $0810,    { MOVE.W    #$0810,-(A7) }
    $A9EB;            { _FP68K, call SANE for the conversion }
var
    result: double_8;
begin
    Convert_10_8(x, result);
    ExtToDbl8 := result;
end;
    {$ENDC}
{$ENDC}

end.